pax_global_header00006660000000000000000000000064141653527220014521gustar00rootroot0000000000000052 comment=1407cab509ff0d96baa4f0eb6ff9980270e6e620 containerd-1.5.9/000077500000000000000000000000001416535272200136635ustar00rootroot00000000000000containerd-1.5.9/.empty-mod/000077500000000000000000000000001416535272200156545ustar00rootroot00000000000000containerd-1.5.9/.empty-mod/go.mod000066400000000000000000000010271416535272200167620ustar00rootroot00000000000000// module empty-mod is an empty module that's used to help with containerd // having a circular dependency on itself through plugin modules. // // We use this module as a "replace" rule in containerd's go.mod, to prevent // relying on transitive dependencies (coming from older versions of containerd // defined on plugin go.mod). // // The replace rule forces go modules to consider the "current" version of // containerd to be the source of truth, helping us catch missing go.mod rules, // or version changes early. module empty-mod containerd-1.5.9/.gitattributes000066400000000000000000000000201416535272200165460ustar00rootroot00000000000000*.go text eol=lfcontainerd-1.5.9/.github/000077500000000000000000000000001416535272200152235ustar00rootroot00000000000000containerd-1.5.9/.github/ISSUE_TEMPLATE/000077500000000000000000000000001416535272200174065ustar00rootroot00000000000000containerd-1.5.9/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000031121416535272200220750ustar00rootroot00000000000000--- name: Bug report about: Create a bug report to help improve containerd title: '' labels: kind/bug assignees: '' --- **Description** **Steps to reproduce the issue:** 1. 2. 3. **Describe the results you received:** **Describe the results you expected:** **What version of containerd are you using:** ``` $ containerd --version ``` **Any other relevant information (runC version, CRI configuration, OS/Kernel version, etc.):**
runc --version
$ runc --version
crictl info
$ crictl info
uname -a
$ uname -a
containerd-1.5.9/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000011311416535272200213720ustar00rootroot00000000000000blank_issues_enabled: true contact_links: - name: Ask a question (GitHub Discussions) url: https://github.com/containerd/containerd/discussions about: | Please do not submit "a bug report" for asking a question. In most cases, GitHub Discussions is the best place to ask a question. If you are not sure whether you are going to report a bug or ask a question, please consider asking in GitHub Discussions first. - name: Chat with containerd users and developers url: https://slack.cncf.io/ about: CNCF slack has `#containerd` and `#containerd-dev` channels containerd-1.5.9/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000006121416535272200231320ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for containerd title: '' labels: kind/feature assignees: '' --- **What is the problem you're trying to solve** A clear and concise description of what the problem is. **Describe the solution you'd like** A clear and concise description of what you'd like to happen. **Additional context** Add any other context about the feature request here.containerd-1.5.9/.github/workflows/000077500000000000000000000000001416535272200172605ustar00rootroot00000000000000containerd-1.5.9/.github/workflows/ci.yml000066400000000000000000000425441416535272200204070ustar00rootroot00000000000000name: CI on: push: branches: - master - 'release/**' pull_request: branches: - master - 'release/**' jobs: # # golangci-lint # linters: name: Linters runs-on: ${{ matrix.os }} timeout-minutes: 10 strategy: matrix: go-version: [1.16.12] os: [ubuntu-18.04, macos-10.15, windows-2019] steps: - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - uses: golangci/golangci-lint-action@v2 with: version: v1.36.0 working-directory: src/github.com/containerd/containerd args: --timeout=5m # # Project checks # project: name: Project Checks runs-on: ubuntu-18.04 timeout-minutes: 5 steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd fetch-depth: 100 - uses: containerd/project-checks@v1 with: working-directory: src/github.com/containerd/containerd # # Protobuf checks # protos: name: Protobuf runs-on: ubuntu-18.04 timeout-minutes: 5 defaults: run: working-directory: src/github.com/containerd/containerd steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "GO111MODULE=off" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - name: Install protobuf run: | sudo -E PATH=$PATH script/setup/install-protobuf sudo chmod +x /usr/local/bin/protoc sudo chmod og+rx /usr/local/include/google /usr/local/include/google/protobuf /usr/local/include/google/protobuf/compiler sudo chmod -R og+r /usr/local/include/google/protobuf/ protoc --version - run: script/setup/install-dev-tools - run: make proto-fmt - run: make check-protos check-api-descriptors man: name: Manpages runs-on: ubuntu-18.04 timeout-minutes: 5 steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - run: GO111MODULE=on go get github.com/cpuguy83/go-md2man/v2@v2.0.0 - run: make man working-directory: src/github.com/containerd/containerd # Make sure binaries compile with other platforms crossbuild: name: Crossbuild Binaries needs: [project, linters, protos, man] runs-on: ubuntu-18.04 timeout-minutes: 10 strategy: fail-fast: false matrix: include: - goos: linux goarch: arm64 - goos: linux goarch: arm goarm: "7" - goos: linux goarch: arm goarm: "5" - goos: freebsd goarch: amd64 - goos: freebsd goarch: arm64 - goos: windows goarch: arm goarm: "7" steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - run: | set -e -x packages="" platform="${{matrix.goos}}/${{matrix.goarch}}" if [ -n "${{matrix.goarm}}" ]; then platform+="/v${{matrix.goarm}}" fi case "${platform}" in linux/arm/v5) packages+=" crossbuild-essential-armel" echo "CGO_ENABLED=1" >> $GITHUB_ENV echo "CC=arm-linux-gnueabi-gcc" >> $GITHUB_ENV ;; linux/arm/v7) packages+=" crossbuild-essential-armhf" echo "CGO_ENABLED=1" >> $GITHUB_ENV echo "CC=arm-linux-gnueabihf-gcc" >> $GITHUB_ENV ;; linux/arm64) packages+=" crossbuild-essential-arm64" echo "CGO_ENABLED=1" >> $GITHUB_ENV echo "CC=aarch64-linux-gnu-gcc" >> $GITHUB_ENV ;; windows/arm/v7) echo "CGO_ENABLED=0" >> $GITHUB_ENV ;; esac if [ -n "${packages}" ]; then sudo apt-get update && sudo apt-get install -y ${packages} fi name: install deps - name: Build working-directory: src/github.com/containerd/containerd env: GOOS: ${{matrix.goos}} GOARCH: ${{matrix.goarch}} GOARM: ${{matrix.goarm}} run: | make build make binaries # # Build containerd binaries # binaries: name: Binaries runs-on: ${{ matrix.os }} timeout-minutes: 10 needs: [project, linters, protos, man] strategy: matrix: os: [ubuntu-18.04, macos-10.15, windows-2019] go-version: ['1.16.12'] include: # Go 1.13.x is still used by Docker/Moby - go-version: '1.13.x' os: ubuntu-18.04 steps: - uses: actions/setup-go@v2 with: go-version: ${{ matrix.go-version }} - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Make run: | make build make binaries working-directory: src/github.com/containerd/containerd # # Integration and CRI tests # integration-windows: name: Windows Integration runs-on: windows-2019 timeout-minutes: 30 needs: [project, linters, protos, man] env: GOTEST: gotestsum -- defaults: run: shell: bash working-directory: src/github.com/containerd/containerd steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - uses: actions/checkout@v2 with: repository: Microsoft/hcsshim path: src/github.com/Microsoft/hcsshim - name: Set env run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH echo "${{ github.workspace }}/src/github.com/containerd/containerd/bin" >> $GITHUB_PATH - run: script/setup/install-dev-tools - name: Binaries env: CGO_ENABLED: 1 run: | set -o xtrace mingw32-make.exe binaries bindir="$(pwd)" SHIM_COMMIT=$(grep 'Microsoft/hcsshim ' go.mod | awk '{print $2}') cd ../../Microsoft/hcsshim git fetch --tags origin "${SHIM_COMMIT}" git checkout "${SHIM_COMMIT}" GO111MODULE=on go build -mod=vendor -o "${bindir}/integration/client/containerd-shim-runhcs-v1.exe" ./cmd/containerd-shim-runhcs-v1 - run: script/setup/install-gotestsum - name: Tests env: CGO_ENABLED: 1 GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-unit-root.xml run: mingw32-make.exe test root-test - name: Integration 1 env: CGO_ENABLED: 1 GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-integration-serial-junit.xml run: mingw32-make.exe integration # Run the integration suite a second time. See discussion in github.com/containerd/containerd/pull/1759 - name: Integration 2 env: TESTFLAGS_PARALLEL: 1 CGO_ENABLED: 1 GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-integration-parallel-junit.xml run: mingw32-make.exe integration - uses: actions/upload-artifact@v2 if: always() with: name: TestResults Windows path: | ${{github.workspace}}/*-junit.xml integration-linux: name: Linux Integration runs-on: ubuntu-18.04 timeout-minutes: 40 needs: [project, linters, protos, man] strategy: fail-fast: false matrix: runtime: [io.containerd.runtime.v1.linux, io.containerd.runc.v1, io.containerd.runc.v2] runc: [runc, crun] exclude: - runtime: io.containerd.runc.v1 runc: crun - runtime: io.containerd.runtime.v1.linux runc: crun env: GOTEST: gotestsum -- steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - name: Install containerd dependencies env: RUNC_FLAVOR: ${{ matrix.runc }} run: | sudo apt-get install -y gperf sudo -E PATH=$PATH script/setup/install-seccomp sudo -E PATH=$PATH script/setup/install-runc sudo -E PATH=$PATH script/setup/install-cni sudo -E PATH=$PATH script/setup/install-critools working-directory: src/github.com/containerd/containerd - name: Install criu run: | sudo apt-get install -y \ libprotobuf-dev \ libprotobuf-c-dev \ protobuf-c-compiler \ protobuf-compiler \ python-protobuf \ libnl-3-dev \ libnet-dev \ libcap-dev \ python-future wget https://github.com/checkpoint-restore/criu/archive/v3.13.tar.gz -O criu.tar.gz tar -zxf criu.tar.gz cd criu-3.13 sudo make install-criu - name: Install containerd env: CGO_ENABLED: 1 run: | make binaries sudo -E PATH=$PATH make install working-directory: src/github.com/containerd/containerd - run: sudo -E PATH=$PATH script/setup/install-gotestsum working-directory: src/github.com/containerd/containerd - name: Tests env: GOPROXY: direct GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-unit-root-junit.xml run: | make test sudo -E PATH=$PATH make root-test working-directory: src/github.com/containerd/containerd - name: Integration 1 env: GOPROXY: direct TEST_RUNTIME: ${{ matrix.runtime }} RUNC_FLAVOR: ${{ matrix.runc }} GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-integration-serial-junit.xml run: | sudo -E PATH=$PATH make integration EXTRA_TESTFLAGS=-no-criu TESTFLAGS_RACE=-race working-directory: src/github.com/containerd/containerd # Run the integration suite a second time. See discussion in github.com/containerd/containerd/pull/1759 - name: Integration 2 env: GOPROXY: direct TEST_RUNTIME: ${{ matrix.runtime }} RUNC_FLAVOR: ${{ matrix.runc }} GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-integration-parallel-junit.xml run: | sudo -E PATH=$PATH TESTFLAGS_PARALLEL=1 make integration EXTRA_TESTFLAGS=-no-criu working-directory: src/github.com/containerd/containerd # CRIU wouldn't work with overlay snapshotter yet. # See https://github.com/containerd/containerd/pull/4708#issuecomment-724322294. - name: CRIU Integration env: GOPROXY: direct TEST_RUNTIME: ${{ matrix.runtime }} RUNC_FLAVOR: ${{ matrix.runc }} GOTESTSUM_JUNITFILE: ${{github.workspace}}/test-integration-criu-junit.xml # crun doesn't have "checkpoint" command. if: ${{ matrix.runc == 'runc' }} run: | sudo -E PATH=$PATH \ TESTFLAGS_PARALLEL=1 \ TEST_SNAPSHOTTER=native \ make integration EXTRA_TESTFLAGS='-run TestCheckpoint' working-directory: src/github.com/containerd/containerd - name: CRI Integration Test env: TEST_RUNTIME: ${{ matrix.runtime }} run: | CONTAINERD_RUNTIME=$TEST_RUNTIME make cri-integration working-directory: src/github.com/containerd/containerd - name: cri-tools critest env: TEST_RUNTIME: ${{ matrix.runtime }} run: | BDIR="$(mktemp -d -p $PWD)" mkdir -p ${BDIR}/{root,state} cat > ${BDIR}/config.toml < ${BDIR}/containerd-cri.log & sudo -E PATH=$PATH /usr/local/bin/ctr -a ${BDIR}/c.sock version sudo -E PATH=$PATH critest --report-dir "${{github.workspace}}/critestreport" --runtime-endpoint=unix:///${BDIR}/c.sock --parallel=8 TEST_RC=$? test $TEST_RC -ne 0 && cat ${BDIR}/containerd-cri.log sudo pkill containerd sudo -E rm -rf ${BDIR} test $TEST_RC -eq 0 || /bin/false # Log the status of this VM to investigate issues like # https://github.com/containerd/containerd/issues/4969 - name: Host Status if: always() run: | set -x mount df losetup -l - uses: actions/upload-artifact@v2 if: always() with: name: TestResults ${{ matrix.runtime }} ${{matrix.runc}} path: | *-junit.xml ${{github.workspace}}/critestreport/*.xml tests-mac-os: name: MacOS unit tests runs-on: macos-10.15 timeout-minutes: 10 needs: [project, linters, protos, man] env: GOTEST: gotestsum -- steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - run: sudo -E PATH=$PATH script/setup/install-gotestsum working-directory: src/github.com/containerd/containerd - name: Tests env: GOPROXY: direct GOTESTSUM_JUNITFILE: "${{ github.workspace }}/macos-test-junit.xml" run: | make test working-directory: src/github.com/containerd/containerd - uses: actions/upload-artifact@v2 if: always() with: name: TestResults MacOS path: | *-junit.xml cgroup2: name: CGroupsV2 and SELinux Integration # nested virtualization is only available on macOS hosts runs-on: macos-10.15 timeout-minutes: 45 needs: [project, linters, protos, man] strategy: matrix: # Currently crun is disabled to decrease CI flakiness. # We can enable crun again when we get a better CI infra. runc: [runc] env: GOTEST: gotestsum -- steps: - uses: actions/checkout@v2 - name: "Cache ~/.vagrant.d/boxes" uses: actions/cache@v2 with: path: ~/.vagrant.d/boxes key: vagrant-${{ hashFiles('Vagrantfile*') }} - name: Vagrant start run: | # Retry if it fails (download.fedoraproject.org returns 404 sometimes) vagrant up || vagrant up - name: Integration env: RUNC_FLAVOR: ${{ matrix.runc }} SELINUX: Enforcing GOTESTSUM_JUNITFILE: /tmp/test-integration-junit.xml run: vagrant up --provision-with=selinux,install-runc,install-gotestsum,test-integration - name: CRI test env: RUNC_FLAVOR: ${{ matrix.runc }} SELINUX: Enforcing REPORT_DIR: /tmp/critestreport run: vagrant up --provision-with=selinux,install-runc,install-gotestsum,test-cri - name: Get test reports if: always() run: | set -e vagrant plugin install vagrant-vbguest vagrant plugin install vagrant-scp vagrant scp :/tmp/test-integration-junit.xml "${{ github.workspace }}/" vagrant scp :/tmp/critestreport "${{ github.workspace }}/critestreport" - uses: actions/upload-artifact@v2 if: always() with: name: TestResults cgroup2 ${{ matrix.runtime }} ${{matrix.runc}} path: | ${{github.workspace}}/*-junit.xml ${{github.workspace}}/critestreport/* containerd-1.5.9/.github/workflows/codeql.yml000066400000000000000000000024631416535272200212570ustar00rootroot00000000000000name: "CodeQL Scan" on: push: schedule: - cron: '0 0 * * 0' pull_request: paths: - '.github/workflows/codeql.yml' jobs: CodeQL-Build: strategy: fail-fast: false # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest runs-on: ubuntu-latest steps: - name: Checkout repository uses: actions/checkout@v2 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v1 # Override language selection by uncommenting this and choosing your languages # with: # languages: go, javascript, csharp, python, cpp, java # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). # If this step fails, then you should remove it and run the build manually (see below). - name: Autobuild uses: github/codeql-action/autobuild@v1 # ℹ️ Command-line programs to run using the OS shell. # 📚 https://git.io/JvXDl # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines # and modify them (or add more) to build your code if your project # uses a compiled language #- run: | # make bootstrap # make release - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v1 containerd-1.5.9/.github/workflows/nightly.yml000066400000000000000000000077761416535272200215020ustar00rootroot00000000000000name: Nightly on: schedule: - cron: '0 0 * * *' # Every day at midnight pull_request: paths: - '.github/workflows/nightly.yml' jobs: linux: name: Linux runs-on: ubuntu-latest defaults: run: working-directory: src/github.com/containerd/containerd steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH # # Build # - name: Install dependencies run: | sudo add-apt-repository "deb [arch=arm64,s390x,ppc64el] http://ports.ubuntu.com/ubuntu-ports/ $(lsb_release -sc) main" || true sudo add-apt-repository "deb [arch=arm64,s390x,ppc64el] http://ports.ubuntu.com/ubuntu-ports/ $(lsb_release -sc)-updates main" || true sudo dpkg --add-architecture arm64 sudo dpkg --add-architecture s390x sudo dpkg --add-architecture ppc64el sudo apt-get update || true sudo apt-get install -y \ crossbuild-essential-arm64 \ crossbuild-essential-s390x \ crossbuild-essential-ppc64el \ libseccomp-dev:amd64 \ libseccomp-dev:arm64 \ libseccomp-dev:s390x \ libseccomp-dev:ppc64el \ libbtrfs-dev:amd64 \ libbtrfs-dev:arm64 \ libbtrfs-dev:s390x \ libbtrfs-dev:ppc64el - name: Build amd64 env: GOOS: linux GOARCH: amd64 run: | make binaries mv bin bin_amd64 - name: Build arm64 env: GOOS: linux GOARCH: arm64 CC: aarch64-linux-gnu-gcc CGO_ENABLED: 1 run: | make binaries mv bin bin_arm64 - name: Build s390x env: GOOS: linux GOARCH: s390x CGO_ENABLED: 1 CC: s390x-linux-gnu-gcc run: | make binaries mv bin bin_s390x - name: Build ppc64le env: GOOS: linux GOARCH: ppc64le CGO_ENABLED: 1 CC: powerpc64le-linux-gnu-gcc run: | make binaries mv bin bin_ppc64le # # Upload # - name: Upload artifacts (linux_amd64) uses: actions/upload-artifact@v1 with: name: linux_amd64 path: src/github.com/containerd/containerd/bin_amd64 - name: Upload artifacts (linux_arm64) uses: actions/upload-artifact@v1 with: name: linux_arm64 path: src/github.com/containerd/containerd/bin_arm64 - name: Upload artifacts (linux_s390x) uses: actions/upload-artifact@v1 with: name: linux_s390x path: src/github.com/containerd/containerd/bin_s390x - name: Upload artifacts (linux_ppc64le) uses: actions/upload-artifact@v1 with: name: linux_ppc64le path: src/github.com/containerd/containerd/bin_ppc64le windows: name: Windows runs-on: windows-latest defaults: run: working-directory: src/github.com/containerd/containerd steps: - uses: actions/setup-go@v2 with: go-version: '1.16.12' - uses: actions/checkout@v2 with: path: src/github.com/containerd/containerd - name: Set env shell: bash run: | echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - name: Build amd64 env: GOOS: windows GOARCH: amd64 run: | make binaries - name: Upload artifacts (windows_amd64) uses: actions/upload-artifact@v1 with: name: windows_amd64 path: src/github.com/containerd/containerd/bin/ containerd-1.5.9/.github/workflows/release.yml000066400000000000000000000222601416535272200214250ustar00rootroot00000000000000on: push: tags: - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10 name: Containerd Release jobs: check: name: Check Signed Tag runs-on: ubuntu-18.04 timeout-minutes: 5 outputs: stringver: ${{ steps.contentrel.outputs.stringver }} steps: - name: Checkout code uses: actions/checkout@v2 with: ref: ${{ github.ref }} path: src/github.com/containerd/containerd - name: Check signature run: | releasever=${{ github.ref }} releasever="${releasever#refs/tags/}" TAGCHECK=$(git tag -v ${releasever} 2>&1 >/dev/null) || echo "${TAGCHECK}" | grep -q "error" && { echo "::error::tag ${releasever} is not a signed tag. Failing release process." exit 1 } || { echo "Tag ${releasever} is signed." exit 0 } working-directory: src/github.com/containerd/containerd - name: Release content id: contentrel run: | RELEASEVER=${{ github.ref }} echo "::set-output name=stringver::${RELEASEVER#refs/tags/v}" git tag -l ${RELEASEVER#refs/tags/} -n20000 | tail -n +3 | cut -c 5- >release-notes.md working-directory: src/github.com/containerd/containerd - name: Save release notes uses: actions/upload-artifact@v2 with: name: containerd-release-notes path: src/github.com/containerd/containerd/release-notes.md build: name: Build Release Binaries runs-on: ${{ matrix.os }} needs: [check] timeout-minutes: 10 strategy: matrix: os: [ubuntu-18.04, windows-2019] steps: - name: Install Go uses: actions/setup-go@v2 with: go-version: '1.16.12' - name: Set env shell: bash env: MOS: ${{ matrix.os }} run: | releasever=${{ github.ref }} releasever="${releasever#refs/tags/}" os=linux [[ "${MOS}" =~ "windows" ]] && { os=windows } echo "RELEASE_VER=${releasever}" >> $GITHUB_ENV echo "GOPATH=${{ github.workspace }}" >> $GITHUB_ENV echo "OS=${os}" >> $GITHUB_ENV echo "${{ github.workspace }}/bin" >> $GITHUB_PATH - name: Checkout containerd uses: actions/checkout@v2 with: repository: containerd/containerd ref: ${{ github.ref }} path: src/github.com/containerd/containerd - name: HCS Shim commit id: hcsshim_commit if: startsWith(matrix.os, 'windows') shell: bash run: echo "::set-output name=sha::$(grep 'Microsoft/hcsshim ' go.mod | awk '{print $2}')" working-directory: src/github.com/containerd/containerd - name: Checkout hcsshim source if: startsWith(matrix.os, 'windows') uses: actions/checkout@v2 with: repository: Microsoft/hcsshim ref: ${{ steps.hcsshim_commit.outputs.sha }} path: src/github.com/Microsoft/hcsshim - name: Make shell: bash run: | make build make binaries rm bin/containerd-stress* [[ "${OS}" == "windows" ]] && { ( bindir="$(pwd)/bin" cd ../../Microsoft/hcsshim GO111MODULE=on go build -mod=vendor -o "${bindir}/containerd-shim-runhcs-v1.exe" ./cmd/containerd-shim-runhcs-v1 ) } TARFILE="containerd-${RELEASE_VER#v}-${OS}-amd64.tar.gz" tar czf ${TARFILE} bin/ sha256sum ${TARFILE} >${TARFILE}.sha256sum working-directory: src/github.com/containerd/containerd - name: Save build binaries uses: actions/upload-artifact@v2 with: name: containerd-binaries-${{ matrix.os }} path: src/github.com/containerd/containerd/*.tar.gz* - name: Make cri-containerd tar shell: bash env: RUNC_FLAVOR: runc run: | if [[ "${OS}" == "linux" ]]; then sudo apt-get update sudo apt-get install -y gperf sudo -E PATH=$PATH script/setup/install-seccomp fi make cri-cni-release working-directory: src/github.com/containerd/containerd - name: Save cri-containerd binaries uses: actions/upload-artifact@v2 with: name: cri-containerd-binaries-${{ matrix.os }} path: src/github.com/containerd/containerd/releases/cri-containerd-cni-*.tar.gz* release: name: Create containerd Release runs-on: ubuntu-18.04 timeout-minutes: 10 needs: [build, check] steps: - name: Download builds and release notes uses: actions/download-artifact@v2 with: path: builds - name: Catalog build assets for upload id: catalog run: | _filenum=1 for i in "ubuntu-18.04" "windows-2019"; do for f in `ls builds/containerd-binaries-${i}`; do echo "::set-output name=file${_filenum}::${f}" let "_filenum+=1" done for f in `ls builds/cri-containerd-binaries-${i}`; do echo "::set-output name=file${_filenum}::${f}" let "_filenum+=1" done done - name: Create Release id: create_release uses: actions/create-release@v1.1.2 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: tag_name: ${{ github.ref }} release_name: containerd ${{ needs.check.outputs.stringver }} body_path: ./builds/containerd-release-notes/release-notes.md draft: false prerelease: ${{ contains(github.ref, 'beta') || contains(github.ref, 'rc') }} - name: Upload Linux containerd tarball uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/containerd-binaries-ubuntu-18.04/${{ steps.catalog.outputs.file1 }} asset_name: ${{ steps.catalog.outputs.file1 }} asset_content_type: application/gzip - name: Upload Linux sha256 sum uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/containerd-binaries-ubuntu-18.04/${{ steps.catalog.outputs.file2 }} asset_name: ${{ steps.catalog.outputs.file2 }} asset_content_type: text/plain - name: Upload Linux cri containerd tarball uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/cri-containerd-binaries-ubuntu-18.04/${{ steps.catalog.outputs.file3 }} asset_name: ${{ steps.catalog.outputs.file3 }} asset_content_type: application/gzip - name: Upload Linux cri sha256 sum uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/cri-containerd-binaries-ubuntu-18.04/${{ steps.catalog.outputs.file4 }} asset_name: ${{ steps.catalog.outputs.file4 }} asset_content_type: text/plain - name: Upload Windows containerd tarball uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/containerd-binaries-windows-2019/${{ steps.catalog.outputs.file5 }} asset_name: ${{ steps.catalog.outputs.file5 }} asset_content_type: application/gzip - name: Upload Windows sha256 sum uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/containerd-binaries-windows-2019/${{ steps.catalog.outputs.file6 }} asset_name: ${{ steps.catalog.outputs.file6 }} asset_content_type: text/plain - name: Upload Windows cri containerd tarball uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/cri-containerd-binaries-windows-2019/${{ steps.catalog.outputs.file7 }} asset_name: ${{ steps.catalog.outputs.file7 }} asset_content_type: application/gzip - name: Upload Windows cri sha256 sum uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./builds/cri-containerd-binaries-windows-2019/${{ steps.catalog.outputs.file8 }} asset_name: ${{ steps.catalog.outputs.file8 }} asset_content_type: text/plain containerd-1.5.9/.gitignore000066400000000000000000000001751416535272200156560ustar00rootroot00000000000000/bin/ /man/ coverage.txt profile.out containerd.test _site/ releases/*.tar.gz releases/*.tar.gz.sha256sum _output/ .vagrant/ containerd-1.5.9/.golangci.yml000066400000000000000000000005051416535272200162470ustar00rootroot00000000000000linters: enable: - structcheck - varcheck - staticcheck - unconvert - gofmt - goimports - golint - ineffassign - vet - unused - misspell disable: - errcheck issues: include: - EXC0002 run: timeout: 3m skip-dirs: - api - design - docs - docs/man containerd-1.5.9/.mailmap000066400000000000000000000137661416535272200153210ustar00rootroot00000000000000Abhinandan Prativadi Abhinandan Prativadi Ace-Tang Akihiro Suda Akihiro Suda Allen Sun Alexander Morozov Antonio Ojea Amit Krishnan Andrei Vagin Andrey Kolomentsev Arnaud Porterie Arnaud Porterie Bob Mader Boris Popovschi Bowen Yan Brent Baude Cao Zhihao Cao Zhihao Carlos Eduardo chenxiaoyu Cory Bennett Cristian Staretu Cristian Staretu Daniel Dao Derek McGowan Edgar Lee Eric Ernst Eric Ren Eric Ren Eric Ren Fahed Dorgaa Frank Yang Fupan Li Fupan Li Georgia Panoutsakopoulou Guangming Wang Haiyan Meng Harry Zhang Hu Shuai Hu Shuai Iceber Gu Jaana Burcu Dogan Jess Valarezo Jess Valarezo Jian Liao Jian Liao Ji'an Liu Jie Zhang John Howard John Howard John Howard John Howard Lorenz Brun Luc Perkins Julien Balestra Jun Lin Chen <1913688+mc256@users.noreply.github.com> Justin Cormack Justin Terry Justin Terry Kenfe-Mickaël Laventure Kevin Kern Kevin Parsons Kevin Xu Kohei Tokunaga Krasi Georgiev Lantao Liu Lantao Liu Li Yuxuan Lifubang Lu Jingxiao Maksym Pavlenko Maksym Pavlenko Mario Hros Mario Hros Mario Macias Mark Gordon Michael Crosby Michael Katsoulis Mike Brown Mohammad Asif Siddiqui Nishchay Kumar Oliver Stenbom Phil Estes Phil Estes Reid Li Robin Winkelewski Ross Boucher Ruediger Maass Rui Cao Sakeven Jiang Samuel Karp Seth Pellegrino <30441101+sethp-nr@users.noreply.github.com> Shaobao Feng Shengbo Song Shengjing Zhu Siddharth Yadav SiYu Zhao Stefan Berger Stefan Berger Stephen J Day Stephen J Day Stephen J Day Sudeesh John Su Fei Su Xiaolin Ted Yu Tõnis Tiigi Wade Lee Wade Lee Wade Lee <21621232@zju.edu.cn> wanglei Wei Fu Wei Fu Xiaodong Zhang Xuean Yan Yue Zhang Yuxing Liu Zhang Wei zhangyadong Zhenguang Zhu Zhiyu Li Zhiyu Li <404977848@qq.com> Zhongming Chang Zhoulin Xie Zhoulin Xie <42261994+JoeWrightss@users.noreply.github.com> 张潇 containerd-1.5.9/.zuul.yaml000066400000000000000000000016551416535272200156330ustar00rootroot00000000000000- project: name: containerd/containerd merge-mode: merge check: jobs: - containerd-build-arm64 - containerd-test-arm64 - containerd-integration-test-arm64 - job: name: containerd-build-arm64 parent: init-test description: | Containerd build in openlab cluster. run: .zuul/playbooks/containerd-build/run.yaml nodeset: ubuntu-xenial-arm64-openlab voting: false - job: name: containerd-test-arm64 parent: init-test description: | Containerd unit tests in openlab cluster. run: .zuul/playbooks/containerd-build/unit-test.yaml nodeset: ubuntu-xenial-arm64-openlab voting: false - job: name: containerd-integration-test-arm64 parent: init-test description: | Containerd unit tests in openlab cluster. run: .zuul/playbooks/containerd-build/integration-test.yaml nodeset: ubuntu-xenial-arm64-openlab voting: false containerd-1.5.9/.zuul/000077500000000000000000000000001416535272200147405ustar00rootroot00000000000000containerd-1.5.9/.zuul/playbooks/000077500000000000000000000000001416535272200167435ustar00rootroot00000000000000containerd-1.5.9/.zuul/playbooks/containerd-build/000077500000000000000000000000001416535272200221665ustar00rootroot00000000000000containerd-1.5.9/.zuul/playbooks/containerd-build/integration-test.yaml000066400000000000000000000054561416535272200263640ustar00rootroot00000000000000- hosts: all become: yes roles: - role: config-golang go_version: '1.16.12' arch: arm64 tasks: - name: Install pre-requisites shell: cmd: | set -xe set -o pipefail apt-get update apt-get install -y btrfs-tools libseccomp-dev git pkg-config lsof gperf apparmor go version chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Install containerd and cri dependencies shell: cmd: | set -xe make install-deps chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Install criu shell: cmd: | set -xe apt-get install -y \ libprotobuf-dev \ libprotobuf-c-dev \ protobuf-c-compiler \ protobuf-compiler \ python-protobuf \ libnl-3-dev \ libnet-dev \ libcap-dev \ python-future wget https://github.com/checkpoint-restore/criu/archive/v3.13.tar.gz -O criu.tar.gz tar -zxf criu.tar.gz cd criu-3.13 make install-criu chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Install containerd shell: cmd: | set -xe make binaries make install | tee $LOGS_PATH/make_install.log chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Tests shell: cmd: | make test | tee $LOGS_PATH/make_test.log make root-test | tee $LOGS_PATH/make_root-test.log chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Integration 1 shell: cmd: | make integration EXTRA_TESTFLAGS=-no-criu TESTFLAGS_RACE=-race | tee $LOGS_PATH/make_integration-test.log chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: Integration 2 shell: cmd: | TESTFLAGS_PARALLEL=1 make integration EXTRA_TESTFLAGS=-no-criu | tee $LOGS_PATH/make_integration-test.log chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: CRI Integration Test shell: cmd: | CONTAINERD_RUNTIME="io.containerd.runc.v2" make cri-integration | tee $LOGS_PATH/make_cri-integration-test.log chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' - name: CRI Integration Test shell: cmd: | if grep -q "FAIL:" $LOGS_PATH/*.log; then echo "FAILURE" exit 1 fi chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' containerd-1.5.9/.zuul/playbooks/containerd-build/run.yaml000066400000000000000000000007561416535272200236660ustar00rootroot00000000000000- hosts: all become: yes roles: - role: config-golang go_version: '1.16.12' arch: arm64 tasks: - name: Build containerd shell: cmd: | set -xe set -o pipefail apt-get update apt-get install -y btrfs-tools libseccomp-dev git pkg-config go version make | tee $LOGS_PATH/make.txt cp -r ./bin $RESULTS_PATH chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' containerd-1.5.9/.zuul/playbooks/containerd-build/unit-test.yaml000066400000000000000000000007441416535272200250130ustar00rootroot00000000000000- hosts: all become: yes roles: - role: config-golang go_version: '1.16.12' arch: arm64 tasks: - name: Build and test containerd shell: cmd: | set -xe set -o pipefail apt-get update apt-get install -y btrfs-tools libseccomp-dev git pkg-config go version make build test | tee $LOGS_PATH/make_test.txt chdir: '{{ zuul.project.src_dir }}' executable: /bin/bash environment: '{{ global_env }}' containerd-1.5.9/ADOPTERS.md000066400000000000000000000130001416535272200154200ustar00rootroot00000000000000## containerd Adopters A non-exhaustive list of containerd adopters is provided below. **_Docker/Moby engine_** - Containerd began life prior to its CNCF adoption as a lower-layer runtime manager for `runc` processes below the Docker engine. Continuing today, containerd has extremely broad production usage as a component of the [Docker engine](https://github.com/docker/docker-ce) stack. Note that this includes any use of the open source [Moby engine project](https://github.com/moby/moby); including the Balena project listed below. **_[IBM Cloud Kubernetes Service (IKS)](https://www.ibm.com/cloud/container-service)_** - offers containerd as the CRI runtime for v1.11 and higher versions. **_[IBM Cloud Private (ICP)](https://www.ibm.com/cloud/private)_** - IBM's on-premises cloud offering has containerd as a "tech preview" CRI runtime for the Kubernetes offered within this product for the past two releases, and plans to fully migrate to containerd in a future release. **_[Google Cloud Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine/)_** - offers containerd as the CRI runtime in **beta** for recent versions of Kubernetes. **_[AWS Fargate](https://aws.amazon.com/fargate)_** - uses containerd + Firecracker (noted below) as the runtime and isolation technology for containers run in the Fargate platform. Fargate is a serverless, container-native compute offering from Amazon Web Services. **_Cloud Foundry_** - The [Guardian container manager](https://github.com/cloudfoundry/guardian) for CF has been using OCI runC directly with additional code from CF managing the container image and filesystem interactions, but have recently migrated to use containerd as a replacement for the extra code they had written around runC. **_Alibaba's PouchContainer_** - The Alibaba [PouchContainer](https://github.com/alibaba/pouch) project uses containerd as its runtime for a cloud native offering that has unique isolation and image distribution capabilities. **_Rancher's k3s project_** - Rancher Labs [k3s](https://github.com/rancher/k3s) is a lightweight Kubernetes distribution; in their words: "Easy to install, half the memory, all in a binary less than 40mb." k8s uses containerd as the embedded runtime for this popular lightweight Kubernetes variant. **_Rancher's Rio project_** - Rancher Labs [Rio](https://github.com/rancher/rio) project uses containerd as the runtime for a combined Kubernetes, Istio, and container "Cloud Native Container Distribution" platform. **_Eliot_** - The [Eliot](https://github.com/ernoaapa/eliot) container project for IoT device container management uses containerd as the runtime. **_Balena_** - Resin's [Balena](https://github.com/resin-os/balena) container engine, based on moby/moby but for edge, embedded, and IoT use cases, uses the containerd and runc stack in the same way that the Docker engine uses containerd. **_LinuxKit_** - the Moby project's [LinuxKit](https://github.com/linuxkit/linuxkit) for building secure, minimal Linux OS images in a container-native model uses containerd as the core runtime for system and service containers. **_BuildKit_** - The Moby project's [BuildKit](https://github.com/moby/buildkit) can use either runC or containerd as build execution backends for building container images. BuildKit support has also been built into the Docker engine in recent releases, making BuildKit provide the backend to the `docker build` command. **_Azure acs-engine_** - Microsoft Azure's [acs-engine](https://github.com/Azure/acs-engine) open source project has customizable deployment of Kubernetes clusters, where containerd is a selectable container runtime. At some point in the future Azure's AKS service will default to use containerd as the CRI runtime for deployed Kubernetes clusters. **_Amazon Firecracker_** - The AWS [Firecracker VMM project](http://firecracker-microvm.io/) has extended containerd with a new snapshotter and v2 shim to allow containerd to drive virtualized container processes via their VMM implementation. More details on their containerd integration are available in [their GitHub project](https://github.com/firecracker-microvm/firecracker-containerd). **_Kata Containers_** - The [Kata containers](https://katacontainers.io/) lightweight-virtualized container runtime project integrates with containerd via a custom v2 shim implementation that drives the Kata container runtime. **_D2iQ Konvoy_** - D2iQ Inc [Konvoy](https://d2iq.com/products/konvoy) product uses containerd as the container runtime for its Kubernetes distribution. **_Inclavare Containers_** - [Inclavare Containers](https://github.com/alibaba/inclavare-containers) is an innovation of container runtime with the novel approach for launching protected containers in hardware-assisted Trusted Execution Environment (TEE) technology, aka Enclave, which can prevent the untrusted entity, such as Cloud Service Provider (CSP), from accessing the sensitive and confidential assets in use. **_Other Projects_** - While the above list provides a cross-section of well known uses of containerd, the simplicity and clear API layer for containerd has inspired many smaller projects around providing simple container management platforms. Several examples of building higher layer functionality on top of the containerd base have come from various containerd community participants: - Michael Crosby's [boss](https://github.com/crosbymichael/boss) project, - Evan Hazlett's [stellar](https://github.com/ehazlett/stellar) project, - Paul Knopf's immutable Linux image builder project: [darch](https://github.com/godarch/darch). containerd-1.5.9/BUILDING.md000066400000000000000000000251151416535272200154060ustar00rootroot00000000000000# Build containerd from source This guide is useful if you intend to contribute on containerd. Thanks for your effort. Every contribution is very appreciated. This doc includes: * [Build requirements](#build-requirements) * [Build the development environment](#build-the-development-environment) * [Build containerd](#build-containerd) * [Via docker container](#via-docker-container) * [Testing](#testing-containerd) ## Build requirements To build the `containerd` daemon, and the `ctr` simple test client, the following build system dependencies are required: * Go 1.13.x or above except 1.14.x * Protoc 3.x compiler and headers (download at the [Google protobuf releases page](https://github.com/google/protobuf/releases)) * Btrfs headers and libraries for your distribution. Note that building the btrfs driver can be disabled via the build tag `no_btrfs`, removing this dependency. ## Build the development environment First you need to setup your Go development environment. You can follow this guideline [How to write go code](https://golang.org/doc/code.html) and at the end you have `go` command in your `PATH`. You need `git` to checkout the source code: ```sh git clone https://github.com/containerd/containerd ``` For proper results, install the `protoc` release into `/usr/local` on your build system. For example, the following commands will download and install the 3.11.4 release for a 64-bit Linux host: ``` $ wget -c https://github.com/google/protobuf/releases/download/v3.11.4/protoc-3.11.4-linux-x86_64.zip $ sudo unzip protoc-3.11.4-linux-x86_64.zip -d /usr/local ``` `containerd` uses [Btrfs](https://en.wikipedia.org/wiki/Btrfs) it means that you need to satisfy these dependencies in your system: * CentOS/Fedora: `yum install btrfs-progs-devel` * Debian/Ubuntu: `apt-get install btrfs-progs libbtrfs-dev` * Debian(before Buster)/Ubuntu(before 19.10): `apt-get install btrfs-tools` At this point you are ready to build `containerd` yourself! ## Build runc `runc` is the default container runtime used by `containerd` and is required to run containerd. While it is okay to download a runc binary and install that on the system, sometimes it is necessary to build runc directly when working with container runtime development. You can skip this step if you already have the correct version of `runc` installed. `runc` requires `libseccomp`. You may need to install the missing dependencies: * CentOS/Fedora: `yum install libseccomp libseccomp-devel` * Debian/Ubuntu: `apt-get install libseccomp libseccomp-dev` For the quick and dirty installation, you can use the following: ``` git clone https://github.com/opencontainers/runc cd runc make sudo make install ``` Make sure to follow the guidelines for versioning in [RUNC.md](/docs/RUNC.md) for the best results. ## Build containerd `containerd` uses `make` to create a repeatable build flow. It means that you can run: ``` cd containerd make ``` This is going to build all the project binaries in the `./bin/` directory. You can move them in your global path, `/usr/local/bin` with: ```sudo sudo make install ``` When making any changes to the gRPC API, you can use the installed `protoc` compiler to regenerate the API generated code packages with: ```sudo make generate ``` > *Note*: Several build tags are currently available: > * `no_btrfs`: A build tag disables building the btrfs snapshot driver. > * `no_cri`: A build tag disables building Kubernetes [CRI](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html) support into containerd. > See [here](https://github.com/containerd/cri-containerd#build-tags) for build tags of CRI plugin. > * `no_devmapper`: A build tag disables building the device mapper snapshot driver. > > For example, adding `BUILDTAGS=no_btrfs` to your environment before calling the **binaries** > Makefile target will disable the btrfs driver within the containerd Go build. Vendoring of external imports uses the [Go Modules](https://golang.org/ref/mod#vendoring). You need to use `go mod` command to modify the dependencies. After modifition, you should run `go mod tidy` and `go mod vendor` to ensure the `go.mod`, `go.sum` files and `vendor` directory are up to date. Changes to these files should become a single commit for a PR which relies on vendored updates. Please refer to [RUNC.md](/docs/RUNC.md) for the currently supported version of `runc` that is used by containerd. ### Static binaries You can build static binaries by providing a few variables to `make`: ```sudo make EXTRA_FLAGS="-buildmode pie" \ EXTRA_LDFLAGS='-linkmode external -extldflags "-fno-PIC -static"' \ BUILDTAGS="netgo osusergo static_build" ``` > *Note*: > - static build is discouraged > - static containerd binary does not support loading shared object plugins (`*.so`) # Via Docker container The following instructions assume you are at the parent directory of containerd source directory. ## Build containerd You can build `containerd` via a Linux-based Docker container. You can build an image from this `Dockerfile`: ``` FROM golang RUN apt-get update && \ apt-get install -y libbtrfs-dev ``` Let's suppose that you built an image called `containerd/build`. From the containerd source root directory you can run the following command: ```sh docker run -it \ -v ${PWD}/containerd:/go/src/github.com/containerd/containerd \ -e GOPATH=/go \ -w /go/src/github.com/containerd/containerd containerd/build sh ``` This mounts `containerd` repository You are now ready to [build](#build-containerd): ```sh make && make install ``` ## Build containerd and runc To have complete core container runtime, you will need both `containerd` and `runc`. It is possible to build both of these via Docker container. You can use `git` to checkout `runc`: ```sh git clone https://github.com/opencontainers/runc ``` We can build an image from this `Dockerfile`: ```sh FROM golang RUN apt-get update && \ apt-get install -y libbtrfs-dev libseccomp-dev ``` In our Docker container we will build `runc` build, which includes [seccomp](https://en.wikipedia.org/wiki/seccomp), [SELinux](https://en.wikipedia.org/wiki/Security-Enhanced_Linux), and [AppArmor](https://en.wikipedia.org/wiki/AppArmor) support. Seccomp support in runc requires `libseccomp-dev` as a dependency (AppArmor and SELinux support do not require external libraries at build time). Refer to [RUNC.md](docs/RUNC.md) in the docs directory to for details about building runc, and to learn about supported versions of `runc` as used by containerd. Let's suppose you build an image called `containerd/build` from the above Dockerfile. You can run the following command: ```sh docker run -it --privileged \ -v /var/lib/containerd \ -v ${PWD}/runc:/go/src/github.com/opencontainers/runc \ -v ${PWD}/containerd:/go/src/github.com/containerd/containerd \ -e GOPATH=/go \ -w /go/src/github.com/containerd/containerd containerd/build sh ``` This mounts both `runc` and `containerd` repositories in our Docker container. From within our Docker container let's build `containerd`: ```sh cd /go/src/github.com/containerd/containerd make && make install ``` These binaries can be found in the `./bin` directory in your host. `make install` will move the binaries in your `$PATH`. Next, let's build `runc`: ```sh cd /go/src/github.com/opencontainers/runc make && make install ``` For further details about building runc, refer to [RUNC.md](docs/RUNC.md) in the docs directory. When working with `ctr`, the simple test client we just built, don't forget to start the daemon! ```sh containerd --config config.toml ``` # Testing containerd During the automated CI the unit tests and integration tests are run as part of the PR validation. As a developer you can run these tests locally by using any of the following `Makefile` targets: - `make test`: run all non-integration tests that do not require `root` privileges - `make root-test`: run all non-integration tests which require `root` - `make integration`: run all tests, including integration tests and those which require `root`. `TESTFLAGS_PARALLEL` can be used to control parallelism. For example, `TESTFLAGS_PARALLEL=1 make integration` will lead a non-parallel execution. The default value of `TESTFLAGS_PARALLEL` is **8**. To execute a specific test or set of tests you can use the `go test` capabilities without using the `Makefile` targets. The following examples show how to specify a test name and also how to use the flag directly against `go test` to run root-requiring tests. ```sh # run the test : go test -v -run "" . # enable the root-requiring tests: go test -v -run . -test.root ``` Example output from directly running `go test` to execute the `TestContainerList` test: ```sh sudo go test -v -run "TestContainerList" . -test.root INFO[0000] running tests against containerd revision=f2ae8a020a985a8d9862c9eb5ab66902c2888361 version=v1.0.0-beta.2-49-gf2ae8a0 === RUN TestContainerList --- PASS: TestContainerList (0.00s) PASS ok github.com/containerd/containerd 4.778s ``` ## Additional tools ### containerd-stress In addition to `go test`-based testing executed via the `Makefile` targets, the `containerd-stress` tool is available and built with the `all` or `binaries` targets and installed during `make install`. With this tool you can stress a running containerd daemon for a specified period of time, selecting a concurrency level to generate stress against the daemon. The following command is an example of having five workers running for two hours against a default containerd gRPC socket address: ```sh containerd-stress -c 5 -t 120 ``` For more information on this tool's options please run `containerd-stress --help`. ### bucketbench [Bucketbench](https://github.com/estesp/bucketbench) is an external tool which can be used to drive load against a container runtime, specifying a particular set of lifecycle operations to run with a specified amount of concurrency. Bucketbench is more focused on generating performance details than simply inducing load against containerd. Bucketbench differs from the `containerd-stress` tool in a few ways: - Bucketbench has support for testing the Docker engine, the `runc` binary, and containerd 0.2.x (via `ctr`) and 1.0 (via the client library) branches. - Bucketbench is driven via configuration file that allows specifying a list of lifecycle operations to execute. This can be used to generate detailed statistics per-command (e.g. start, stop, pause, delete). - Bucketbench generates detailed reports and timing data at the end of the configured test run. More details on how to install and run `bucketbench` are available at the [GitHub project page](https://github.com/estesp/bucketbench). containerd-1.5.9/LICENSE000066400000000000000000000250151416535272200146730ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 https://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 Copyright The containerd 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 https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. containerd-1.5.9/Makefile000066400000000000000000000332571416535272200153350ustar00rootroot00000000000000# Copyright The containerd 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. # Go command to use for build GO ?= go # Root directory of the project (absolute path). ROOTDIR=$(dir $(abspath $(lastword $(MAKEFILE_LIST)))) # Base path used to install. DESTDIR ?= /usr/local TEST_IMAGE_LIST ?= # Used to populate variables in version package. VERSION=$(shell git describe --match 'v[0-9]*' --dirty='.m' --always) REVISION=$(shell git rev-parse HEAD)$(shell if ! git diff --no-ext-diff --quiet --exit-code; then echo .m; fi) PACKAGE=github.com/containerd/containerd SHIM_CGO_ENABLED ?= 0 ifneq "$(strip $(shell command -v $(GO) 2>/dev/null))" "" GOOS ?= $(shell $(GO) env GOOS) GOARCH ?= $(shell $(GO) env GOARCH) else ifeq ($(GOOS),) # approximate GOOS for the platform if we don't have Go and GOOS isn't # set. We leave GOARCH unset, so that may need to be fixed. ifeq ($(OS),Windows_NT) GOOS = windows else UNAME_S := $(shell uname -s) ifeq ($(UNAME_S),Linux) GOOS = linux endif ifeq ($(UNAME_S),Darwin) GOOS = darwin endif ifeq ($(UNAME_S),FreeBSD) GOOS = freebsd endif endif else GOOS ?= $$GOOS GOARCH ?= $$GOARCH endif endif ifndef GODEBUG EXTRA_LDFLAGS += -s -w DEBUG_GO_GCFLAGS := DEBUG_TAGS := else DEBUG_GO_GCFLAGS := -gcflags=all="-N -l" DEBUG_TAGS := static_build endif WHALE = "🇩" ONI = "👹" RELEASE=containerd-$(VERSION:v%=%).${GOOS}-${GOARCH} CRIRELEASE=cri-containerd-$(VERSION:v%=%)-${GOOS}-${GOARCH} CRICNIRELEASE=cri-containerd-cni-$(VERSION:v%=%)-${GOOS}-${GOARCH} PKG=github.com/containerd/containerd # Project binaries. COMMANDS=ctr containerd containerd-stress MANPAGES=ctr.8 containerd.8 containerd-config.8 containerd-config.toml.5 ifdef BUILDTAGS GO_BUILDTAGS = ${BUILDTAGS} endif GO_BUILDTAGS ?= GO_BUILDTAGS += ${DEBUG_TAGS} GO_TAGS=$(if $(GO_BUILDTAGS),-tags "$(GO_BUILDTAGS)",) GO_LDFLAGS=-ldflags '-X $(PKG)/version.Version=$(VERSION) -X $(PKG)/version.Revision=$(REVISION) -X $(PKG)/version.Package=$(PACKAGE) $(EXTRA_LDFLAGS)' SHIM_GO_LDFLAGS=-ldflags '-X $(PKG)/version.Version=$(VERSION) -X $(PKG)/version.Revision=$(REVISION) -X $(PKG)/version.Package=$(PACKAGE) -extldflags "-static" $(EXTRA_LDFLAGS)' # Project packages. PACKAGES=$(shell $(GO) list ${GO_TAGS} ./... | grep -v /vendor/ | grep -v /integration) TEST_REQUIRES_ROOT_PACKAGES=$(filter \ ${PACKAGES}, \ $(shell \ for f in $$(git grep -l testutil.RequiresRoot | grep -v Makefile); do \ d="$$(dirname $$f)"; \ [ "$$d" = "." ] && echo "${PKG}" && continue; \ echo "${PKG}/$$d"; \ done | sort -u) \ ) ifdef SKIPTESTS PACKAGES:=$(filter-out ${SKIPTESTS},${PACKAGES}) TEST_REQUIRES_ROOT_PACKAGES:=$(filter-out ${SKIPTESTS},${TEST_REQUIRES_ROOT_PACKAGES}) endif #Replaces ":" (*nix), ";" (windows) with newline for easy parsing GOPATHS=$(shell echo ${GOPATH} | tr ":" "\n" | tr ";" "\n") TESTFLAGS_RACE= GO_BUILD_FLAGS= # See Golang issue re: '-trimpath': https://github.com/golang/go/issues/13809 GO_GCFLAGS=$(shell \ set -- ${GOPATHS}; \ echo "-gcflags=-trimpath=$${1}/src"; \ ) BINARIES=$(addprefix bin/,$(COMMANDS)) #include platform specific makefile -include Makefile.$(GOOS) # Flags passed to `go test` TESTFLAGS ?= $(TESTFLAGS_RACE) $(EXTRA_TESTFLAGS) TESTFLAGS_PARALLEL ?= 8 # Use this to replace `go test` with, for instance, `gotestsum` GOTEST ?= $(GO) test OUTPUTDIR = $(join $(ROOTDIR), _output) CRIDIR=$(OUTPUTDIR)/cri .PHONY: clean all AUTHORS build binaries test integration generate protos checkprotos coverage ci check help install uninstall vendor release mandir install-man genman install-cri-deps cri-release cri-cni-release cri-integration install-deps bin/cri-integration.test .DEFAULT: default all: binaries check: proto-fmt ## run all linters @echo "$(WHALE) $@" GOGC=75 golangci-lint run ci: check binaries checkprotos coverage coverage-integration ## to be used by the CI AUTHORS: .mailmap .git/HEAD git log --format='%aN <%aE>' | sort -fu > $@ generate: protos @echo "$(WHALE) $@" @PATH="${ROOTDIR}/bin:${PATH}" $(GO) generate -x ${PACKAGES} protos: bin/protoc-gen-gogoctrd ## generate protobuf @echo "$(WHALE) $@" @PATH="${ROOTDIR}/bin:${PATH}" protobuild --quiet ${PACKAGES} check-protos: protos ## check if protobufs needs to be generated again @echo "$(WHALE) $@" @test -z "$$(git status --short | grep ".pb.go" | tee /dev/stderr)" || \ ((git diff | cat) && \ (echo "$(ONI) please run 'make protos' when making changes to proto files" && false)) check-api-descriptors: protos ## check that protobuf changes aren't present. @echo "$(WHALE) $@" @test -z "$$(git status --short | grep ".pb.txt" | tee /dev/stderr)" || \ ((git diff $$(find . -name '*.pb.txt') | cat) && \ (echo "$(ONI) please run 'make protos' when making changes to proto files and check-in the generated descriptor file changes" && false)) proto-fmt: ## check format of proto files @echo "$(WHALE) $@" @test -z "$$(find . -path ./vendor -prune -o -path ./protobuf/google/rpc -prune -o -name '*.proto' -type f -exec grep -Hn -e "^ " {} \; | tee /dev/stderr)" || \ (echo "$(ONI) please indent proto files with tabs only" && false) @test -z "$$(find . -path ./vendor -prune -o -name '*.proto' -type f -exec grep -Hn "Meta meta = " {} \; | grep -v '(gogoproto.nullable) = false' | tee /dev/stderr)" || \ (echo "$(ONI) meta fields in proto files must have option (gogoproto.nullable) = false" && false) build: ## build the go packages @echo "$(WHALE) $@" @$(GO) build ${DEBUG_GO_GCFLAGS} ${GO_GCFLAGS} ${GO_BUILD_FLAGS} ${EXTRA_FLAGS} ${GO_LDFLAGS} ${PACKAGES} test: ## run tests, except integration tests and tests that require root @echo "$(WHALE) $@" @$(GOTEST) ${TESTFLAGS} ${PACKAGES} root-test: ## run tests, except integration tests @echo "$(WHALE) $@" @$(GOTEST) ${TESTFLAGS} ${TEST_REQUIRES_ROOT_PACKAGES} -test.root integration: ## run integration tests @echo "$(WHALE) $@" @cd "${ROOTDIR}/integration/client" && $(GO) mod download && $(GOTEST) -v ${TESTFLAGS} -test.root -parallel ${TESTFLAGS_PARALLEL} . # TODO integrate cri integration bucket with coverage bin/cri-integration.test: @echo "$(WHALE) $@" @$(GO) test -c ./integration -o bin/cri-integration.test cri-integration: binaries bin/cri-integration.test ## run cri integration tests @echo "$(WHALE) $@" @./script/test/cri-integration.sh @rm -rf bin/cri-integration.test benchmark: ## run benchmarks tests @echo "$(WHALE) $@" @$(GO) test ${TESTFLAGS} -bench . -run Benchmark -test.root FORCE: define BUILD_BINARY @echo "$(WHALE) $@" @$(GO) build ${DEBUG_GO_GCFLAGS} ${GO_GCFLAGS} ${GO_BUILD_FLAGS} -o $@ ${GO_LDFLAGS} ${GO_TAGS} ./$< endef # Build a binary from a cmd. bin/%: cmd/% FORCE $(call BUILD_BINARY) bin/containerd-shim: cmd/containerd-shim FORCE # set !cgo and omit pie for a static shim build: https://github.com/golang/go/issues/17789#issuecomment-258542220 @echo "$(WHALE) bin/containerd-shim" @CGO_ENABLED=${SHIM_CGO_ENABLED} $(GO) build ${GO_BUILD_FLAGS} -o bin/containerd-shim ${SHIM_GO_LDFLAGS} ${GO_TAGS} ./cmd/containerd-shim bin/containerd-shim-runc-v1: cmd/containerd-shim-runc-v1 FORCE # set !cgo and omit pie for a static shim build: https://github.com/golang/go/issues/17789#issuecomment-258542220 @echo "$(WHALE) bin/containerd-shim-runc-v1" @CGO_ENABLED=${SHIM_CGO_ENABLED} $(GO) build ${GO_BUILD_FLAGS} -o bin/containerd-shim-runc-v1 ${SHIM_GO_LDFLAGS} ${GO_TAGS} ./cmd/containerd-shim-runc-v1 bin/containerd-shim-runc-v2: cmd/containerd-shim-runc-v2 FORCE # set !cgo and omit pie for a static shim build: https://github.com/golang/go/issues/17789#issuecomment-258542220 @echo "$(WHALE) bin/containerd-shim-runc-v2" @CGO_ENABLED=${SHIM_CGO_ENABLED} $(GO) build ${GO_BUILD_FLAGS} -o bin/containerd-shim-runc-v2 ${SHIM_GO_LDFLAGS} ${GO_TAGS} ./cmd/containerd-shim-runc-v2 binaries: $(BINARIES) ## build binaries @echo "$(WHALE) $@" man: mandir $(addprefix man/,$(MANPAGES)) @echo "$(WHALE) $@" mandir: @mkdir -p man # Kept for backwards compatibility genman: man/containerd.8 man/ctr.8 man/containerd.8: FORCE @echo "$(WHALE) $@" $(GO) run cmd/gen-manpages/main.go $(@F) $(@D) man/ctr.8: FORCE @echo "$(WHALE) $@" $(GO) run cmd/gen-manpages/main.go $(@F) $(@D) man/%: docs/man/%.md FORCE @echo "$(WHALE) $@" go-md2man -in "$<" -out "$@" define installmanpage mkdir -p $(DESTDIR)/man/man$(2); gzip -c $(1) >$(DESTDIR)/man/man$(2)/$(3).gz; endef install-man: @echo "$(WHALE) $@" $(foreach manpage,$(addprefix man/,$(MANPAGES)), $(call installmanpage,$(manpage),$(subst .,,$(suffix $(manpage))),$(notdir $(manpage)))) releases/$(RELEASE).tar.gz: $(BINARIES) @echo "$(WHALE) $@" @rm -rf releases/$(RELEASE) releases/$(RELEASE).tar.gz @install -d releases/$(RELEASE)/bin @install $(BINARIES) releases/$(RELEASE)/bin @tar -czf releases/$(RELEASE).tar.gz -C releases/$(RELEASE) bin @rm -rf releases/$(RELEASE) release: releases/$(RELEASE).tar.gz @echo "$(WHALE) $@" @cd releases && sha256sum $(RELEASE).tar.gz >$(RELEASE).tar.gz.sha256sum # install of cri deps into release output directory ifeq ($(GOOS),windows) install-cri-deps: $(BINARIES) mkdir -p $(CRIDIR) DESTDIR=$(CRIDIR) script/setup/install-cni-windows cp bin/* $(CRIDIR) else install-cri-deps: $(BINARIES) @rm -rf ${CRIDIR} @install -d ${CRIDIR}/usr/local/bin @install -D -m 755 bin/* ${CRIDIR}/usr/local/bin @install -d ${CRIDIR}/opt/containerd/cluster @cp -r contrib/gce ${CRIDIR}/opt/containerd/cluster/ @install -d ${CRIDIR}/etc/systemd/system @install -m 644 containerd.service ${CRIDIR}/etc/systemd/system echo "CONTAINERD_VERSION: '$(VERSION:v%=%)'" | tee ${CRIDIR}/opt/containerd/cluster/version DESTDIR=$(CRIDIR) script/setup/install-runc DESTDIR=$(CRIDIR) script/setup/install-cni DESTDIR=$(CRIDIR) script/setup/install-critools DESTDIR=$(CRIDIR) script/setup/install-imgcrypt @install -d $(CRIDIR)/bin @install $(BINARIES) $(CRIDIR)/bin endif ifeq ($(GOOS),windows) releases/$(CRIRELEASE).tar.gz: install-cri-deps @echo "$(WHALE) $@" @cd $(CRIDIR) && tar -czf ../../releases/$(CRIRELEASE).tar.gz * releases/$(CRICNIRELEASE).tar.gz: install-cri-deps @echo "$(WHALE) $@" @cd $(CRIDIR) && tar -czf ../../releases/$(CRICNIRELEASE).tar.gz * else releases/$(CRIRELEASE).tar.gz: install-cri-deps @echo "$(WHALE) $@" @tar -czf releases/$(CRIRELEASE).tar.gz -C $(CRIDIR) etc/crictl.yaml etc/systemd usr opt/containerd releases/$(CRICNIRELEASE).tar.gz: install-cri-deps @echo "$(WHALE) $@" @tar -czf releases/$(CRICNIRELEASE).tar.gz -C $(CRIDIR) etc usr opt endif cri-release: releases/$(CRIRELEASE).tar.gz @echo "$(WHALE) $@" @cd releases && sha256sum $(CRIRELEASE).tar.gz >$(CRIRELEASE).tar.gz.sha256sum && ln -sf $(CRIRELEASE).tar.gz cri-containerd.tar.gz cri-cni-release: releases/$(CRICNIRELEASE).tar.gz @echo "$(WHALE) $@" @cd releases && sha256sum $(CRICNIRELEASE).tar.gz >$(CRICNIRELEASE).tar.gz.sha256sum && ln -sf $(CRICNIRELEASE).tar.gz cri-cni-containerd.tar.gz clean: ## clean up binaries @echo "$(WHALE) $@" @rm -f $(BINARIES) @rm -f releases/*.tar.gz* @rm -rf $(OUTPUTDIR) @rm -rf bin/cri-integration.test clean-test: ## clean up debris from previously failed tests @echo "$(WHALE) $@" $(eval containers=$(shell find /run/containerd/runc -mindepth 2 -maxdepth 3 -type d -exec basename {} \;)) $(shell pidof containerd containerd-shim runc | xargs -r -n 1 kill -9) @( for container in $(containers); do \ grep $$container /proc/self/mountinfo | while read -r mountpoint; do \ umount $$(echo $$mountpoint | awk '{print $$5}'); \ done; \ find /sys/fs/cgroup -name $$container -print0 | xargs -r -0 rmdir; \ done ) @rm -rf /run/containerd/runc/* @rm -rf /run/containerd/fifo/* @rm -rf /run/containerd-test/* @rm -rf bin/cri-integration.test install: ## install binaries @echo "$(WHALE) $@ $(BINARIES)" @mkdir -p $(DESTDIR)/bin @install $(BINARIES) $(DESTDIR)/bin uninstall: @echo "$(WHALE) $@" @rm -f $(addprefix $(DESTDIR)/bin/,$(notdir $(BINARIES))) ifeq ($(GOOS),windows) install-deps: # TODO: need a script for hcshim something like containerd/cri/hack/install/windows/install-hcsshim.sh script/setup/install-critools script/setup/install-cni-windows else install-deps: ## install cri dependencies script/setup/install-seccomp script/setup/install-runc script/setup/install-critools script/setup/install-cni endif coverage: ## generate coverprofiles from the unit tests, except tests that require root @echo "$(WHALE) $@" @rm -f coverage.txt @$(GO) test -i ${TESTFLAGS} ${PACKAGES} 2> /dev/null @( for pkg in ${PACKAGES}; do \ $(GO) test ${TESTFLAGS} \ -cover \ -coverprofile=profile.out \ -covermode=atomic $$pkg || exit; \ if [ -f profile.out ]; then \ cat profile.out >> coverage.txt; \ rm profile.out; \ fi; \ done ) root-coverage: ## generate coverage profiles for unit tests that require root @echo "$(WHALE) $@" @$(GO) test -i ${TESTFLAGS} ${TEST_REQUIRES_ROOT_PACKAGES} 2> /dev/null @( for pkg in ${TEST_REQUIRES_ROOT_PACKAGES}; do \ $(GO) test ${TESTFLAGS} \ -cover \ -coverprofile=profile.out \ -covermode=atomic $$pkg -test.root || exit; \ if [ -f profile.out ]; then \ cat profile.out >> coverage.txt; \ rm profile.out; \ fi; \ done ) vendor: ## vendor @echo "$(WHALE) $@" @$(GO) mod tidy @$(GO) mod vendor help: ## this help @awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST) | sort containerd-1.5.9/Makefile.darwin000066400000000000000000000013431416535272200166070ustar00rootroot00000000000000# Copyright The containerd 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. #darwin specific settings COMMANDS += containerd-shim # amd64 supports go test -race ifeq ($(GOARCH),amd64) TESTFLAGS_RACE= -race endif containerd-1.5.9/Makefile.freebsd000066400000000000000000000013441416535272200167360ustar00rootroot00000000000000# Copyright The containerd 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. #freebsd specific settings COMMANDS += containerd-shim # amd64 supports go test -race ifeq ($(GOARCH),amd64) TESTFLAGS_RACE= -race endif containerd-1.5.9/Makefile.linux000066400000000000000000000017361416535272200164700ustar00rootroot00000000000000# Copyright The containerd 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. #linux specific settings WHALE="+" ONI="-" COMMANDS += containerd-shim containerd-shim-runc-v1 containerd-shim-runc-v2 # check GOOS for cross compile builds ifeq ($(GOOS),linux) ifneq ($(GOARCH),$(filter $(GOARCH),mips mipsle mips64 mips64le ppc64 riscv64)) GO_GCFLAGS += -buildmode=pie endif endif # amd64 supports go test -race ifeq ($(GOARCH),amd64) TESTFLAGS_RACE= -race endif containerd-1.5.9/Makefile.windows000066400000000000000000000014611416535272200170160ustar00rootroot00000000000000# Copyright The containerd 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. #Windows specific settings. WHALE = "+" ONI = "-" # amd64 supports go test -race ifeq ($(GOARCH),amd64) TESTFLAGS_RACE= -race endif BINARIES:=$(addsuffix .exe,$(BINARIES)) bin/%.exe: cmd/% FORCE $(BUILD_BINARY) containerd-1.5.9/NOTICE000066400000000000000000000010071416535272200145650ustar00rootroot00000000000000Docker Copyright 2012-2015 Docker, Inc. This product includes software developed at Docker, Inc. (https://www.docker.com). The following is courtesy of our legal counsel: Use and transfer of Docker may be subject to certain restrictions by the United States and other governments. It is your responsibility to ensure that your use and/or transfer does not violate applicable laws. For more information, please see https://www.bis.doc.gov See also https://www.apache.org/dev/crypto.html and/or seek legal counsel. containerd-1.5.9/Protobuild.toml000066400000000000000000000052721416535272200167110ustar00rootroot00000000000000version = "unstable" generator = "gogoctrd" plugins = ["grpc", "fieldpath"] # Control protoc include paths. Below are usually some good defaults, but feel # free to try it without them if it works for your project. [includes] # Include paths that will be added before all others. Typically, you want to # treat the root of the project as an include, but this may not be necessary. before = ["./protobuf"] # Paths that should be treated as include roots in relation to the vendor # directory. These will be calculated with the vendor directory nearest the # target package. packages = ["github.com/gogo/protobuf", "github.com/gogo/googleapis"] # Paths that will be added untouched to the end of the includes. We use # `/usr/local/include` to pickup the common install location of protobuf. # This is the default. after = ["/usr/local/include", "/usr/include"] # This section maps protobuf imports to Go packages. These will become # `-M` directives in the call to the go protobuf generator. [packages] "gogoproto/gogo.proto" = "github.com/gogo/protobuf/gogoproto" "google/protobuf/any.proto" = "github.com/gogo/protobuf/types" "google/protobuf/empty.proto" = "github.com/gogo/protobuf/types" "google/protobuf/descriptor.proto" = "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" "google/protobuf/field_mask.proto" = "github.com/gogo/protobuf/types" "google/protobuf/timestamp.proto" = "github.com/gogo/protobuf/types" "google/protobuf/duration.proto" = "github.com/gogo/protobuf/types" "google/rpc/status.proto" = "github.com/gogo/googleapis/google/rpc" [[overrides]] prefixes = ["github.com/containerd/containerd/api/events"] plugins = ["fieldpath"] # disable grpc for this package [[overrides]] prefixes = ["github.com/containerd/containerd/api/services/ttrpc/events/v1"] plugins = ["ttrpc", "fieldpath"] [[overrides]] # enable ttrpc and disable fieldpath and grpc for the shim prefixes = ["github.com/containerd/containerd/runtime/v1/shim/v1", "github.com/containerd/containerd/runtime/v2/task"] plugins = ["ttrpc"] # Aggregrate the API descriptors to lock down API changes. [[descriptors]] prefix = "github.com/containerd/containerd/api" target = "api/next.pb.txt" ignore_files = [ "google/protobuf/descriptor.proto", "gogoproto/gogo.proto" ] # Lock down runc config [[descriptors]] prefix = "github.com/containerd/containerd/runtime/linux/runctypes" target = "runtime/linux/runctypes/next.pb.txt" ignore_files = [ "google/protobuf/descriptor.proto", "gogoproto/gogo.proto" ] [[descriptors]] prefix = "github.com/containerd/containerd/runtime/v2/runc/options" target = "runtime/v2/runc/options/next.pb.txt" ignore_files = [ "google/protobuf/descriptor.proto", "gogoproto/gogo.proto" ] containerd-1.5.9/README.md000066400000000000000000000363361416535272200151550ustar00rootroot00000000000000![containerd banner](https://raw.githubusercontent.com/cncf/artwork/master/projects/containerd/horizontal/color/containerd-horizontal-color.png) [![PkgGoDev](https://pkg.go.dev/badge/github.com/containerd/containerd)](https://pkg.go.dev/github.com/containerd/containerd) [![Build Status](https://github.com/containerd/containerd/workflows/CI/badge.svg)](https://github.com/containerd/containerd/actions?query=workflow%3ACI) [![Nightlies](https://github.com/containerd/containerd/workflows/Nightly/badge.svg)](https://github.com/containerd/containerd/actions?query=workflow%3ANightly) [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fcontainerd%2Fcontainerd.svg?type=shield)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fcontainerd%2Fcontainerd?ref=badge_shield) [![Go Report Card](https://goreportcard.com/badge/github.com/containerd/containerd)](https://goreportcard.com/report/github.com/containerd/containerd) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/1271/badge)](https://bestpractices.coreinfrastructure.org/projects/1271) containerd is an industry-standard container runtime with an emphasis on simplicity, robustness and portability. It is available as a daemon for Linux and Windows, which can manage the complete container lifecycle of its host system: image transfer and storage, container execution and supervision, low-level storage and network attachments, etc. containerd is a member of CNCF with ['graduated'](https://landscape.cncf.io/selected=containerd) status. containerd is designed to be embedded into a larger system, rather than being used directly by developers or end-users. ![architecture](design/architecture.png) ## Now Recruiting We are a large inclusive OSS project that is welcoming help of any kind shape or form: * Documentation help is needed to make the product easier to consume and extend. * We need OSS community outreach / organizing help to get the word out; manage and create messaging and educational content; and to help with social media, community forums/groups, and google groups. * We are actively inviting new [security advisors](https://github.com/containerd/project/blob/master/GOVERNANCE.md#security-advisors) to join the team. * New sub-projects are being created, core and non-core that could use additional development help. * Each of the [containerd projects](https://github.com/containerd) has a list of issues currently being worked on or that need help resolving. - If the issue has not already been assigned to someone, or has not made recent progress and you are interested, please inquire. - If you are interested in starting with a smaller / beginner level issue, look for issues with an `exp/beginner` tag, for example [containerd/containerd beginner issues.](https://github.com/containerd/containerd/issues?q=is%3Aissue+is%3Aopen+label%3Aexp%2Fbeginner) ## Getting Started See our documentation on [containerd.io](https://containerd.io): * [for ops and admins](docs/ops.md) * [namespaces](docs/namespaces.md) * [client options](docs/client-opts.md) See how to build containerd from source at [BUILDING](BUILDING.md). If you are interested in trying out containerd see our example at [Getting Started](docs/getting-started.md). ## Nightly builds There are nightly builds available for download [here](https://github.com/containerd/containerd/actions?query=workflow%3ANightly). Binaries are generated from `master` branch every night for `Linux` and `Windows`. Please be aware: nightly builds might have critical bugs, it's not recommended for use in production and no support provided. ## Runtime Requirements Runtime requirements for containerd are very minimal. Most interactions with the Linux and Windows container feature sets are handled via [runc](https://github.com/opencontainers/runc) and/or OS-specific libraries (e.g. [hcsshim](https://github.com/Microsoft/hcsshim) for Microsoft). The current required version of `runc` is described in [RUNC.md](docs/RUNC.md). There are specific features used by containerd core code and snapshotters that will require a minimum kernel version on Linux. With the understood caveat of distro kernel versioning, a reasonable starting point for Linux is a minimum 4.x kernel version. The overlay filesystem snapshotter, used by default, uses features that were finalized in the 4.x kernel series. If you choose to use btrfs, there may be more flexibility in kernel version (minimum recommended is 3.18), but will require the btrfs kernel module and btrfs tools to be installed on your Linux distribution. To use Linux checkpoint and restore features, you will need `criu` installed on your system. See more details in [Checkpoint and Restore](#checkpoint-and-restore). Build requirements for developers are listed in [BUILDING](BUILDING.md). ## Features ### Client containerd offers a full client package to help you integrate containerd into your platform. ```go import ( "github.com/containerd/containerd" "github.com/containerd/containerd/cio" ) func main() { client, err := containerd.New("/run/containerd/containerd.sock") defer client.Close() } ``` ### Namespaces Namespaces allow multiple consumers to use the same containerd without conflicting with each other. It has the benefit of sharing content but still having separation with containers and images. To set a namespace for requests to the API: ```go context = context.Background() // create a context for docker docker = namespaces.WithNamespace(context, "docker") containerd, err := client.NewContainer(docker, "id") ``` To set a default namespace on the client: ```go client, err := containerd.New(address, containerd.WithDefaultNamespace("docker")) ``` ### Distribution ```go // pull an image image, err := client.Pull(context, "docker.io/library/redis:latest") // push an image err := client.Push(context, "docker.io/library/redis:latest", image.Target()) ``` ### Containers In containerd, a container is a metadata object. Resources such as an OCI runtime specification, image, root filesystem, and other metadata can be attached to a container. ```go redis, err := client.NewContainer(context, "redis-master") defer redis.Delete(context) ``` ### OCI Runtime Specification containerd fully supports the OCI runtime specification for running containers. We have built in functions to help you generate runtime specifications based on images as well as custom parameters. You can specify options when creating a container about how to modify the specification. ```go redis, err := client.NewContainer(context, "redis-master", containerd.WithNewSpec(oci.WithImageConfig(image))) ``` ### Root Filesystems containerd allows you to use overlay or snapshot filesystems with your containers. It comes with built in support for overlayfs and btrfs. ```go // pull an image and unpack it into the configured snapshotter image, err := client.Pull(context, "docker.io/library/redis:latest", containerd.WithPullUnpack) // allocate a new RW root filesystem for a container based on the image redis, err := client.NewContainer(context, "redis-master", containerd.WithNewSnapshot("redis-rootfs", image), containerd.WithNewSpec(oci.WithImageConfig(image)), ) // use a readonly filesystem with multiple containers for i := 0; i < 10; i++ { id := fmt.Sprintf("id-%s", i) container, err := client.NewContainer(ctx, id, containerd.WithNewSnapshotView(id, image), containerd.WithNewSpec(oci.WithImageConfig(image)), ) } ``` ### Tasks Taking a container object and turning it into a runnable process on a system is done by creating a new `Task` from the container. A task represents the runnable object within containerd. ```go // create a new task task, err := redis.NewTask(context, cio.NewCreator(cio.WithStdio)) defer task.Delete(context) // the task is now running and has a pid that can be used to setup networking // or other runtime settings outside of containerd pid := task.Pid() // start the redis-server process inside the container err := task.Start(context) // wait for the task to exit and get the exit status status, err := task.Wait(context) ``` ### Checkpoint and Restore If you have [criu](https://criu.org/Main_Page) installed on your machine you can checkpoint and restore containers and their tasks. This allows you to clone and/or live migrate containers to other machines. ```go // checkpoint the task then push it to a registry checkpoint, err := task.Checkpoint(context) err := client.Push(context, "myregistry/checkpoints/redis:master", checkpoint) // on a new machine pull the checkpoint and restore the redis container checkpoint, err := client.Pull(context, "myregistry/checkpoints/redis:master") redis, err = client.NewContainer(context, "redis-master", containerd.WithNewSnapshot("redis-rootfs", checkpoint)) defer container.Delete(context) task, err = redis.NewTask(context, cio.NewCreator(cio.WithStdio), containerd.WithTaskCheckpoint(checkpoint)) defer task.Delete(context) err := task.Start(context) ``` ### Snapshot Plugins In addition to the built-in Snapshot plugins in containerd, additional external plugins can be configured using GRPC. An external plugin is made available using the configured name and appears as a plugin alongside the built-in ones. To add an external snapshot plugin, add the plugin to containerd's config file (by default at `/etc/containerd/config.toml`). The string following `proxy_plugin.` will be used as the name of the snapshotter and the address should refer to a socket with a GRPC listener serving containerd's Snapshot GRPC API. Remember to restart containerd for any configuration changes to take effect. ``` [proxy_plugins] [proxy_plugins.customsnapshot] type = "snapshot" address = "/var/run/mysnapshotter.sock" ``` See [PLUGINS.md](/docs/PLUGINS.md) for how to create plugins ### Releases and API Stability Please see [RELEASES.md](RELEASES.md) for details on versioning and stability of containerd components. Downloadable 64-bit Intel/AMD binaries of all official releases are available on our [releases page](https://github.com/containerd/containerd/releases). For other architectures and distribution support, you will find that many Linux distributions package their own containerd and provide it across several architectures, such as [Canonical's Ubuntu packaging](https://launchpad.net/ubuntu/bionic/+package/containerd). #### Enabling command auto-completion Starting with containerd 1.4, the urfave client feature for auto-creation of bash and zsh autocompletion data is enabled. To use the autocomplete feature in a bash shell for example, source the autocomplete/ctr file in your `.bashrc`, or manually like: ``` $ source ./contrib/autocomplete/ctr ``` #### Distribution of `ctr` autocomplete for bash and zsh For bash, copy the `contrib/autocomplete/ctr` script into `/etc/bash_completion.d/` and rename it to `ctr`. The `zsh_autocomplete` file is also available and can be used similarly for zsh users. Provide documentation to users to `source` this file into their shell if you don't place the autocomplete file in a location where it is automatically loaded for the user's shell environment. ### CRI `cri` is a [containerd](https://containerd.io/) plugin implementation of the Kubernetes [container runtime interface (CRI)](https://github.com/kubernetes/cri-api/blob/master/pkg/apis/runtime/v1alpha2/api.proto). With it, you are able to use containerd as the container runtime for a Kubernetes cluster. ![cri](./docs/cri/cri.png) #### CRI Status `cri` is a native plugin of containerd. Since containerd 1.1, the cri plugin is built into the release binaries and enabled by default. > **Note:** As of containerd 1.5, the `cri` plugin is merged into the containerd/containerd repo. For example, the source code previously stored under [`containerd/cri/pkg`](https://github.com/containerd/cri/tree/release/1.4/pkg) was moved to [`containerd/containerd/pkg/cri` package](https://github.com/containerd/containerd/tree/master/pkg/cri). The `cri` plugin has reached GA status, representing that it is: * Feature complete * Works with Kubernetes 1.10 and above * Passes all [CRI validation tests](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/cri-validation.md). * Passes all [node e2e tests](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/e2e-node-tests.md). * Passes all [e2e tests](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-testing/e2e-tests.md). See results on the containerd k8s [test dashboard](https://k8s-testgrid.appspot.com/sig-node-containerd) #### Validating Your `cri` Setup A Kubernetes incubator project, [cri-tools](https://github.com/kubernetes-sigs/cri-tools), includes programs for exercising CRI implementations. More importantly, cri-tools includes the program `critest` which is used for running [CRI Validation Testing](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/cri-validation.md). #### CRI Guides * [Installing with Ansible and Kubeadm](contrib/ansible/README.md) * [For Non-Ansible Users, Preforming a Custom Installation Using the Release Tarball and Kubeadm](docs/cri/installation.md) * [CRI Plugin Testing Guide](./docs/cri/testing.md) * [Debugging Pods, Containers, and Images with `crictl`](./docs/cri/crictl.md) * [Configuring `cri` Plugins](./docs/cri/config.md) * [Configuring containerd](https://github.com/containerd/containerd/blob/master/docs/man/containerd-config.8.md) ### Communication For async communication and long running discussions please use issues and pull requests on the github repo. This will be the best place to discuss design and implementation. For sync communication catch us in the `#containerd` and `#containerd-dev` slack channels on Cloud Native Computing Foundation's (CNCF) slack - `cloud-native.slack.com`. Everyone is welcome to join and chat. [Get Invite to CNCF slack.](https://slack.cncf.io) ### Security audit A third party security audit was performed by Cure53 in 4Q2018; the [full report](docs/SECURITY_AUDIT.pdf) is available in our docs/ directory. ### Reporting security issues __If you are reporting a security issue, please reach out discreetly at security@containerd.io__. ## Licenses The containerd codebase is released under the [Apache 2.0 license](LICENSE). The README.md file, and files in the "docs" folder are licensed under the Creative Commons Attribution 4.0 International License. You may obtain a copy of the license, titled CC-BY-4.0, at http://creativecommons.org/licenses/by/4.0/. ## Project details **containerd** is the primary open source project within the broader containerd GitHub repository. However, all projects within the repo have common maintainership, governance, and contributing guidelines which are stored in a `project` repository commonly for all containerd projects. Please find all these core project documents, including the: * [Project governance](https://github.com/containerd/project/blob/master/GOVERNANCE.md), * [Maintainers](https://github.com/containerd/project/blob/master/MAINTAINERS), * and [Contributing guidelines](https://github.com/containerd/project/blob/master/CONTRIBUTING.md) information in our [`containerd/project`](https://github.com/containerd/project) repository. ## Adoption Interested to see who is using containerd? Are you using containerd in a project? Please add yourself via pull request to our [ADOPTERS.md](./ADOPTERS.md) file. containerd-1.5.9/RELEASES.md000066400000000000000000000366021416535272200154170ustar00rootroot00000000000000# Versioning and Release This document details the versioning and release plan for containerd. Stability is a top goal for this project and we hope that this document and the processes it entails will help to achieve that. It covers the release process, versioning numbering, backporting, API stability and support horizons. If you rely on containerd, it would be good to spend time understanding the areas of the API that are and are not supported and how they impact your project in the future. This document will be considered a living document. Supported timelines, backport targets and API stability guarantees will be updated here as they change. If there is something that you require or this document leaves out, please reach out by [filing an issue](https://github.com/containerd/containerd/issues). ## Releases Releases of containerd will be versioned using dotted triples, similar to [Semantic Version](http://semver.org/). For the purposes of this document, we will refer to the respective components of this triple as `..`. The version number may have additional information, such as alpha, beta and release candidate qualifications. Such releases will be considered "pre-releases". ### Major and Minor Releases Major and minor releases of containerd will be made from master. Releases of containerd will be marked with GPG signed tags and announced at https://github.com/containerd/containerd/releases. The tag will be of the format `v..` and should be made with the command `git tag -s v..`. After a minor release, a branch will be created, with the format `release/.` from the minor tag. All further patch releases will be done from that branch. For example, once we release `v1.0.0`, a branch `release/1.0` will be created from that tag. All future patch releases will be done against that branch. ### Pre-releases Pre-releases, such as alphas, betas and release candidates will be conducted from their source branch. For major and minor releases, these releases will be done from master. For patch releases, these pre-releases should be done within the corresponding release branch. While pre-releases are done to assist in the stabilization process, no guarantees are provided. ### Upgrade Path The upgrade path for containerd is such that the 0.0.x patch releases are always backward compatible with its major and minor version. Minor (0.x.0) version will always be compatible with the previous minor release. i.e. 1.2.0 is backwards compatible with 1.1.0 and 1.1.0 is compatible with 1.0.0. There is no compatibility guarantees for upgrades that span multiple, _minor_ releases. For example, 1.0.0 to 1.2.0 is not supported. One should first upgrade to 1.1, then 1.2. There are no compatibility guarantees with upgrades to _major_ versions. For example, upgrading from 1.0.0 to 2.0.0 may require resources to migrated or integrations to change. Each major version will be supported for at least 1 year with bug fixes and security patches. ### Next Release The activity for the next release will be tracked in the [milestones](https://github.com/containerd/containerd/milestones). If your issue or PR is not present in a milestone, please reach out to the maintainers to create the milestone or add an issue or PR to an existing milestone. ### Support Horizon Support horizons will be defined corresponding to a release branch, identified by `.`. Releases branches will be in one of several states: - __*Next*__: The next planned release branch. - __*Active*__: The release branch is currently supported and accepting patches. - __*Extended*__: The release branch is only accepting security patches. - __*End of Life*__: The release branch is no longer supported and no new patches will be accepted. Releases will be supported up to one year after a _minor_ release. This means that we will accept bug reports and backports to release branches until the end of life date. If no new _minor_ release has been made, that release will be considered supported until 6 months after the next _minor_ is released or one year, whichever is longer. Additionally, releases may have an extended security support period after the end of the active period to accept security backports. This timeframe will be decided by maintainers before the end of the active status. The current state is available in the following table: | Release | Status | Start | End of Life | |---------|-------------|------------------|-------------------| | [0.0](https://github.com/containerd/containerd/releases/tag/0.0.5) | End of Life | Dec 4, 2015 | - | | [0.1](https://github.com/containerd/containerd/releases/tag/v0.1.0) | End of Life | Mar 21, 2016 | - | | [0.2](https://github.com/containerd/containerd/tree/v0.2.x) | End of Life | Apr 21, 2016 | December 5, 2017 | | [1.0](https://github.com/containerd/containerd/releases/tag/v1.0.3) | End of Life | December 5, 2017 | December 5, 2018 | | [1.1](https://github.com/containerd/containerd/releases/tag/v1.1.8) | End of Life | April 23, 2018 | October 23, 2019 | | [1.2](https://github.com/containerd/containerd/releases/tag/v1.2.13) | End of Life | October 24, 2018 | October 15, 2020 | | [1.3](https://github.com/containerd/containerd/releases/tag/v1.3.10) | End of Life | September 26, 2019 | March 4, 2021 | | [1.4](https://github.com/containerd/containerd/releases/tag/v1.4.4) | Active | August 17, 2020 | max(August 17, 2021, release of 1.5.0 + 6 months) | | [1.5](https://github.com/containerd/containerd/milestone/30) | Next | TBD | max(TBD+1 year, release of 1.6.0 + 6 months) | Note that branches and release from before 1.0 may not follow these rules. This table should be updated as part of the release preparation process. ### Backporting Backports in containerd are community driven. As maintainers, we'll try to ensure that sensible bugfixes make it into _active_ release, but our main focus will be features for the next _minor_ or _major_ release. For the most part, this process is straightforward and we are here to help make it as smooth as possible. If there are important fixes that need to be backported, please let use know in one of three ways: 1. Open an issue. 2. Open a PR with cherry-picked change from master. 3. Open a PR with a ported fix. __If you are reporting a security issue, please reach out discreetly at security@containerd.io__. Remember that backported PRs must follow the versioning guidelines from this document. Any release that is "active" can accept backports. Opening a backport PR is fairly straightforward. The steps differ depending on whether you are pulling a fix from master or need to draft a new commit specific to a particular branch. To cherry pick a straightforward commit from master, simply use the cherry pick process: 1. Pick the branch to which you want backported, usually in the format `release/.`. The following will create a branch you can use to open a PR: ```console $ git checkout -b my-backport-branch release/.. ``` 2. Find the commit you want backported. 3. Apply it to the release branch: ```console $ git cherry-pick -xsS ``` 4. Push the branch and open up a PR against the _release branch_: ``` $ git push -u stevvooe my-backport-branch ``` Make sure to replace `stevvooe` with whatever fork you are using to open the PR. When you open the PR, make sure to switch `master` with whatever release branch you are targeting with the fix. Make sure the PR title has `[]` prefixed. e.g.: ``` [release/1.4] Fix foo in bar ``` If there is no existing fix in master, you should first fix the bug in master, or ask us a maintainer or contributor to do it via an issue. Once that PR is completed, open a PR using the process above. Only when the bug is not seen in master and must be made for the specific release branch should you open a PR with new code. ## Public API Stability The following table provides an overview of the components covered by containerd versions: | Component | Status | Stabilized Version | Links | |------------------|----------|--------------------|---------------| | GRPC API | Stable | 1.0 | [api/](api) | | Metrics API | Stable | 1.0 | - | | Runtime Shim API | Stable | 1.2 | - | | Daemon Config | Stable | 1.0 | - | | Go client API | Unstable | _future_ | [godoc](https://godoc.org/github.com/containerd/containerd) | | CRI GRPC API | Unstable | v1alpha2 _current_ | [cri-api](https://github.com/kubernetes/cri-api/tree/master/pkg/apis/runtime/v1alpha2) | | `ctr` tool | Unstable | Out of scope | - | From the version stated in the above table, that component must adhere to the stability constraints expected in release versions. Unless explicitly stated here, components that are called out as unstable or not covered may change in a future minor version. Breaking changes to "unstable" components will be avoided in patch versions. ### GRPC API The primary product of containerd is the GRPC API. As of the 1.0.0 release, the GRPC API will not have any backwards incompatible changes without a _major_ version jump. To ensure compatibility, we have collected the entire GRPC API symbol set into a single file. At each _minor_ release of containerd, we will move the current `next.pb.txt` file to a file named for the minor version, such as `1.0.pb.txt`, enumerating the support services and messages. See [api/](api) for details. Note that new services may be added in _minor_ releases. New service methods and new fields on messages may be added if they are optional. `*.pb.txt` files are generated at each API release. They prevent unintentional changes to the API by having a diff that the CI can run. These files are not intended to be consumed or used by clients. ### Metrics API The metrics API that outputs prometheus style metrics will be versioned independently, prefixed with the API version. i.e. `/v1/metrics`, `/v2/metrics`. The metrics API version will be incremented when breaking changes are made to the prometheus output. New metrics can be added to the output in a backwards compatible manner without bumping the API version. ### Plugins API containerd is based on a modular design where plugins are implemented to provide the core functionality. Plugins implemented in tree are supported by the containerd community unless explicitly specified as non-stable. Out of tree plugins are not supported by the containerd maintainers. Currently, the Windows runtime and snapshot plugins are not stable and not supported. Please refer to the github milestones for Windows support in a future release. #### Error Codes Error codes will not change in a patch release, unless a missing error code causes a blocking bug. Error codes of type "unknown" may change to more specific types in the future. Any error code that is not "unknown" that is currently returned by a service will not change without a _major_ release or a new version of the service. If you find that an error code that is required by your application is not well-documented in the protobuf service description or tested explicitly, please file and issue and we will clarify. #### Opaque Fields Unless explicitly stated, the formats of certain fields may not be covered by this guarantee and should be treated opaquely. For example, don't rely on the format details of a URL field unless we explicitly say that the field will follow that format. ### Go client API The Go client API, documented in [godoc](https://godoc.org/github.com/containerd/containerd), is currently considered unstable. It is recommended to vendor the necessary components to stabilize your project build. Note that because the Go API interfaces with the GRPC API, clients written against a 1.0 Go API should remain compatible with future 1.x series releases. We intend to stabilize the API in a future release when more integrations have been carried out. Any changes to the API should be detectable at compile time, so upgrading will be a matter of fixing compilation errors and moving from there. ### CRI GRPC API The CRI (Container Runtime Interface) GRPC API is used by a Kubernetes kubelet to communicate with a container runtime. This interface is used to manage container lifecycles and container images. Currently this API is under development and unstable across Kubernetes releases. Each Kubernetes release only supports a single version of CRI and the CRI plugin only implements a single version of CRI. Each _minor_ release will support one version of CRI and at least one version of Kubernetes. Once this API is stable, a _minor_ will be compatible with any version of Kubernetes which supports that version of CRI. ### `ctr` tool The `ctr` tool provides the ability to introspect and understand the containerd API. It is not considered a primary offering of the project and is unsupported in that sense. While we understand it's value as a debug tool, it may be completely refactored or have breaking changes in _minor_ releases. Targeting `ctr` for feature additions reflects a misunderstanding of the containerd architecture. Feature addition should focus on the client Go API and additions to `ctr` may or may not be accepted at the discretion of the maintainers. We will do our best to not break compatibility in the tool in _patch_ releases. ### Daemon Configuration The daemon's configuration file, commonly located in `/etc/containerd/config.toml` is versioned and backwards compatible. The `version` field in the config file specifies the config's version. If no version number is specified inside the config file then it is assumed to be a version 1 config and parsed as such. Please use `version = 2` to enable version 2 config as version 1 has been deprecated. ### Not Covered As a general rule, anything not mentioned in this document is not covered by the stability guidelines and may change in any release. Explicitly, this pertains to this non-exhaustive list of components: - File System layout - Storage formats - Snapshot formats Between upgrades of subsequent, _minor_ versions, we may migrate these formats. Any outside processes relying on details of these file system layouts may break in that process. Container root file systems will be maintained on upgrade. ### Exceptions We may make exceptions in the interest of __security patches__. If a break is required, it will be communicated clearly and the solution will be considered against total impact. ## Deprecated features The deprecated features are shown in the following table: | Component | Deprecation release | Target release for removal | Recommendation | |----------------------------------------------------------------------|---------------------|----------------------------|-------------------------------| | Runtime V1 API and implementation (`io.containerd.runtime.v1.linux`) | containerd v1.4 | containerd v2.0 | Use `io.containerd.runc.v2` | | Runc V1 implementation of Runtime V2 (`io.containerd.runc.v1`) | containerd v1.4 | containerd v2.0 | Use `io.containerd.runc.v2` | | config.toml `version = 1` | containerd v1.5 | containerd v2.0 | Use config.toml `version = 2` | | Built-in `aufs` snapshotter | containerd v1.5 | containerd v2.0 | Use `overlayfs` snapshotter | containerd-1.5.9/ROADMAP.md000066400000000000000000000025041416535272200152710ustar00rootroot00000000000000# containerd roadmap containerd uses the issues and milestones to define its roadmap. `ROADMAP.md` files are common in open source projects but we find they quickly become out of date. We opt for an issues and milestone approach that our maintainers and community can keep up-to-date as work is added and completed. ## Issues Issues tagged with the `roadmap` label are high level roadmap items. They are tasks and/or features that the containerd community wants completed. Smaller issues and pull requests can reference back to the main roadmap issue that is tagged to help detail progress towards the overall goal. ## Milestones Milestones define when an issue, pull request, and/or roadmap item is to be completed. Issues are the what, milestones are the when. Development is complex therefore roadmap items can move between milestones depending on the remaining development and testing required to release a change. ## Searching To find the roadmap items currently planned for containerd you can filter on the `roadmap` label. [Search Roadmap Items](https://github.com/containerd/containerd/issues?q=is%3Aopen+is%3Aissue+label%3Aroadmap) After searching for roadmap items you can view what milestone they are scheduled to be completed in along with the progress. [View Milestones](https://github.com/containerd/containerd/milestones) containerd-1.5.9/SCOPE.md000066400000000000000000000110331416535272200150540ustar00rootroot00000000000000# Scope and Principles Having a clearly defined scope of a project is important for ensuring consistency and focus. These following criteria will be used when reviewing pull requests, features, and changes for the project before being accepted. ### Components Components should not have tight dependencies on each other so that they are able to be used independently. The APIs for images and containers should be designed in a way that when used together the components have a natural flow but still be useful independently. An example for this design can be seen with the overlay filesystems and the container execution layer. The execution layer and overlay filesystems can be used independently but if you were to use both, they share a common `Mount` struct that the filesystems produce and the execution layer consumes. ### Primitives containerd should expose primitives to solve problems instead of building high level abstractions in the API. A common example of this is how build would be implemented. Instead of having a build API in containerd we should expose the lower level primitives that allow things required in build to work. Breaking up the filesystem APIs to allow snapshots, copy functionality, and mounts allow people implementing build at the higher levels with more flexibility. ### Extensibility and Defaults For the various components in containerd there should be defined extension points where implementations can be swapped for alternatives. The best example of this is that containerd will use `runc` from OCI as the default runtime in the execution layer but other runtimes conforming to the OCI Runtime specification can be easily added to containerd. containerd will come with a default implementation for the various components. These defaults will be chosen by the maintainers of the project and should not change unless better tech for that component comes out. Additional implementations will not be accepted into the core repository and should be developed in a separate repository not maintained by the containerd maintainers. ## Scope The following table specifies the various components of containerd and general features of container runtimes. The table specifies whether or not the feature/component is in or out of scope. | Name | Description | In/Out | Reason | |------------------------------|--------------------------------------------------------------------------------------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | execution | Provide an extensible execution layer for executing a container | in | Create,start, stop pause, resume exec, signal, delete | | cow filesystem | Built in functionality for overlay, aufs, and other copy on write filesystems for containers | in | | | distribution | Having the ability to push and pull images as well as operations on images as a first class API object | in | containerd will fully support the management and retrieval of images | | metrics | container-level metrics, cgroup stats, and OOM events | in | | networking | creation and management of network interfaces | out | Networking will be handled and provided to containerd via higher level systems. | | build | Building images as a first class API | out | Build is a higher level tooling feature and can be implemented in many different ways on top of containerd | | volumes | Volume management for external data | out | The API supports mounts, binds, etc where all volumes type systems can be built on top of containerd. | | logging | Persisting container logs | out | Logging can be build on top of containerd because the container’s STDIO will be provided to the clients and they can persist any way they see fit. There is no io copying of container STDIO in containerd. | containerd is scoped to a single host and makes assumptions based on that fact. It can be used to build things like a node agent that launches containers but does not have any concepts of a distributed system. containerd is designed to be embedded into a larger system, hence it only includes a barebone CLI (`ctr`) specifically for development and debugging purpose, with no mandate to be human-friendly, and no guarantee of interface stability over time. ### How is the scope changed? The scope of this project is an allowed list. If it's not mentioned as being in scope, it is out of scope. For the scope of this project to change it requires a 100% vote from all maintainers of the project. containerd-1.5.9/Vagrantfile000066400000000000000000000214441416535272200160550ustar00rootroot00000000000000# -*- mode: ruby -*- # vi: set ft=ruby : # Copyright The containerd 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. # Vagrantfile for cgroup2 and SELinux Vagrant.configure("2") do |config| config.vm.box = "fedora/34-cloud-base" memory = 4096 cpus = 2 config.vm.provider :virtualbox do |v| v.memory = memory v.cpus = cpus end config.vm.provider :libvirt do |v| v.memory = memory v.cpus = cpus end # Disabled by default. To run: # vagrant up --provision-with=upgrade-packages # To upgrade only specific packages: # UPGRADE_PACKAGES=selinux vagrant up --provision-with=upgrade-packages # config.vm.provision "upgrade-packages", type: "shell", run: "never" do |sh| sh.upload_path = "/tmp/vagrant-upgrade-packages" sh.env = { 'UPGRADE_PACKAGES': ENV['UPGRADE_PACKAGES'], } sh.inline = <<~SHELL #!/usr/bin/env bash set -eux -o pipefail dnf -y upgrade ${UPGRADE_PACKAGES} SHELL end # To re-run, installing CNI from RPM: # INSTALL_PACKAGES="containernetworking-plugins" vagrant up --provision-with=install-packages # config.vm.provision "install-packages", type: "shell", run: "once" do |sh| sh.upload_path = "/tmp/vagrant-install-packages" sh.env = { 'INSTALL_PACKAGES': ENV['INSTALL_PACKAGES'], } sh.inline = <<~SHELL #!/usr/bin/env bash set -eux -o pipefail dnf -y install \ container-selinux \ curl \ gcc \ git \ iptables \ libseccomp-devel \ libselinux-devel \ lsof \ make \ ${INSTALL_PACKAGES} SHELL end # To re-run this provisioner, installing a different version of go: # GO_VERSION="1.14.6" vagrant up --provision-with=install-golang # config.vm.provision "install-golang", type: "shell", run: "once" do |sh| sh.upload_path = "/tmp/vagrant-install-golang" sh.env = { 'GO_VERSION': ENV['GO_VERSION'] || "1.16.12", } sh.inline = <<~SHELL #!/usr/bin/env bash set -eux -o pipefail curl -fsSL "https://dl.google.com/go/go${GO_VERSION}.linux-amd64.tar.gz" | tar Cxz /usr/local cat >> /etc/environment <> /etc/profile.d/sh.local < /tmp/containerd.log systemctl stop containerd } selinux=$(getenforce) if [[ $selinux == Enforcing ]]; then setenforce 0 fi systemctl enable --now ${GOPATH}/src/github.com/containerd/containerd/containerd.service if [[ $selinux == Enforcing ]]; then setenforce 1 fi trap cleanup EXIT ctr version critest --parallel=$(nproc) --report-dir="${REPORT_DIR}" --ginkgo.skip='HostIpc is true' SHELL end end containerd-1.5.9/api/000077500000000000000000000000001416535272200144345ustar00rootroot00000000000000containerd-1.5.9/api/1.0.pb.txt000066400000000000000000002620061416535272200161010ustar00rootroot00000000000000file { name: "google/protobuf/any.proto" package: "google.protobuf" message_type { name: "Any" field { name: "type_url" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "typeUrl" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "value" } } options { java_package: "com.google.protobuf" java_outer_classname: "AnyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/any" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" package: "containerd.plugin" dependency: "google/protobuf/descriptor.proto" extension { name: "fieldpath_all" extendee: ".google.protobuf.FileOptions" number: 63300 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpathAll" } extension { name: "fieldpath" extendee: ".google.protobuf.MessageOptions" number: 64400 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpath" } } file { name: "github.com/containerd/containerd/api/events/container.proto" package: "containerd.events" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContainerCreate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.ContainerCreate.Runtime" json_name: "runtime" } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } } message_type { name: "ContainerUpdate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.ContainerUpdate.LabelsEntry" json_name: "labels" } field { name: "snapshot_key" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ContainerDelete" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 1 weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/content.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContentDelete" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/image.proto" package: "containerd.services.images.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ImageCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/namespace.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "NamespaceCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/snapshot.proto" package: "containerd.events" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "SnapshotPrepare" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } } message_type { name: "SnapshotCommit" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "SnapshotRemove" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "google/protobuf/timestamp.proto" package: "google.protobuf" message_type { name: "Timestamp" field { name: "seconds" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "seconds" } field { name: "nanos" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "nanos" } } options { java_package: "com.google.protobuf" java_outer_classname: "TimestampProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/timestamp" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/mount.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Mount" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "source" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "source" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "target" } field { name: "options" number: 4 label: LABEL_REPEATED type: TYPE_STRING json_name: "options" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/task.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "TaskCreate" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "bundle" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "bundle" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "io" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.TaskIO" options { 65004: "IO" } json_name: "io" } field { name: "checkpoint" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } field { name: "pid" number: 6 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskStart" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskDelete" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "TaskIO" field { name: "stdin" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } } message_type { name: "TaskExit" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "TaskOOM" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskExecAdded" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "TaskExecStarted" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskPaused" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskResumed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskCheckpointed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 3 syntax: "proto3" } file { name: "google/protobuf/empty.proto" package: "google.protobuf" message_type { name: "Empty" } options { java_package: "com.google.protobuf" java_outer_classname: "EmptyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/empty" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "google/protobuf/field_mask.proto" package: "google.protobuf" message_type { name: "FieldMask" field { name: "paths" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "paths" } } options { java_package: "com.google.protobuf" java_outer_classname: "FieldMaskProto" java_multiple_files: true go_package: "google.golang.org/genproto/protobuf/field_mask;field_mask" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/containers/v1/containers.proto" package: "containerd.services.containers.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Container" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.LabelsEntry" json_name: "labels" } field { name: "image" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.Runtime" json_name: "runtime" } field { name: "spec" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "snapshotter" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "snapshot_key" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } field { name: "created_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "extensions" number: 10 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.ExtensionsEntry" options { 65001: 0 } json_name: "extensions" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } nested_type { name: "ExtensionsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "value" } options { map_entry: true } } } message_type { name: "GetContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "GetContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "ListContainersRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContainersResponse" field { name: "containers" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "containers" } } message_type { name: "CreateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "CreateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "UpdateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "DeleteContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } service { name: "Containers" method { name: "Get" input_type: ".containerd.services.containers.v1.GetContainerRequest" output_type: ".containerd.services.containers.v1.GetContainerResponse" } method { name: "List" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainersResponse" } method { name: "Create" input_type: ".containerd.services.containers.v1.CreateContainerRequest" output_type: ".containerd.services.containers.v1.CreateContainerResponse" } method { name: "Update" input_type: ".containerd.services.containers.v1.UpdateContainerRequest" output_type: ".containerd.services.containers.v1.UpdateContainerResponse" } method { name: "Delete" input_type: ".containerd.services.containers.v1.DeleteContainerRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/containers/v1;containers" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/content/v1/content.proto" package: "containerd.services.content.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/empty.proto" message_type { name: "Info" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "size" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "created_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "InfoRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "InfoResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateRequest" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListContentRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContentResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "DeleteContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "ReadContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "offset" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } message_type { name: "ReadContentResponse" field { name: "offset" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } } message_type { name: "Status" field { name: "started_at" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "startedAt" } field { name: "updated_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "ref" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "expected" } } message_type { name: "StatusRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } message_type { name: "StatusResponse" field { name: "status" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" json_name: "status" } } message_type { name: "ListStatusesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListStatusesResponse" field { name: "statuses" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" options { 65001: 0 } json_name: "statuses" } } message_type { name: "WriteContentRequest" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "ref" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "total" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "expected" } field { name: "offset" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 6 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } field { name: "labels" number: 7 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.WriteContentRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "WriteContentResponse" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "started_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "startedAt" } field { name: "updated_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "digest" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "AbortRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } enum_type { name: "WriteAction" value { name: "STAT" number: 0 options { 66001: "WriteActionStat" } } value { name: "WRITE" number: 1 options { 66001: "WriteActionWrite" } } value { name: "COMMIT" number: 2 options { 66001: "WriteActionCommit" } } options { 62001: 0 62023: "WriteAction" } } service { name: "Content" method { name: "Info" input_type: ".containerd.services.content.v1.InfoRequest" output_type: ".containerd.services.content.v1.InfoResponse" } method { name: "Update" input_type: ".containerd.services.content.v1.UpdateRequest" output_type: ".containerd.services.content.v1.UpdateResponse" } method { name: "List" input_type: ".containerd.services.content.v1.ListContentRequest" output_type: ".containerd.services.content.v1.ListContentResponse" server_streaming: true } method { name: "Delete" input_type: ".containerd.services.content.v1.DeleteContentRequest" output_type: ".google.protobuf.Empty" } method { name: "Read" input_type: ".containerd.services.content.v1.ReadContentRequest" output_type: ".containerd.services.content.v1.ReadContentResponse" server_streaming: true } method { name: "Status" input_type: ".containerd.services.content.v1.StatusRequest" output_type: ".containerd.services.content.v1.StatusResponse" } method { name: "ListStatuses" input_type: ".containerd.services.content.v1.ListStatusesRequest" output_type: ".containerd.services.content.v1.ListStatusesResponse" } method { name: "Write" input_type: ".containerd.services.content.v1.WriteContentRequest" output_type: ".containerd.services.content.v1.WriteContentResponse" client_streaming: true server_streaming: true } method { name: "Abort" input_type: ".containerd.services.content.v1.AbortRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/content/v1;content" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/descriptor.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Descriptor" field { name: "media_type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "digest" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/diff/v1/diff.proto" package: "containerd.services.diff.v1" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "ApplyRequest" field { name: "diff" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } field { name: "mounts" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ApplyResponse" field { name: "applied" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "applied" } } message_type { name: "DiffRequest" field { name: "left" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "left" } field { name: "right" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "right" } field { name: "media_type" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "ref" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.diff.v1.DiffRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "DiffResponse" field { name: "diff" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } } service { name: "Diff" method { name: "Apply" input_type: ".containerd.services.diff.v1.ApplyRequest" output_type: ".containerd.services.diff.v1.ApplyResponse" } method { name: "Diff" input_type: ".containerd.services.diff.v1.DiffRequest" output_type: ".containerd.services.diff.v1.DiffResponse" } } options { go_package: "github.com/containerd/containerd/api/services/diff/v1;diff" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/events/v1/events.proto" package: "containerd.services.events.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "PublishRequest" field { name: "topic" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } } message_type { name: "ForwardRequest" field { name: "envelope" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.events.v1.Envelope" json_name: "envelope" } } message_type { name: "SubscribeRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "Envelope" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "timestamp" } field { name: "namespace" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "namespace" } field { name: "topic" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } options { 64400: 1 } } service { name: "Events" method { name: "Publish" input_type: ".containerd.services.events.v1.PublishRequest" output_type: ".google.protobuf.Empty" } method { name: "Forward" input_type: ".containerd.services.events.v1.ForwardRequest" output_type: ".google.protobuf.Empty" } method { name: "Subscribe" input_type: ".containerd.services.events.v1.SubscribeRequest" output_type: ".containerd.services.events.v1.Envelope" server_streaming: true } } options { go_package: "github.com/containerd/containerd/api/services/events/v1;events" } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/images/v1/images.proto" package: "containerd.services.images.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "Image" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image.LabelsEntry" json_name: "labels" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" options { 65001: 0 } json_name: "target" } field { name: "created_at" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" json_name: "image" } } message_type { name: "CreateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "CreateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "UpdateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "ListImagesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListImagesResponse" field { name: "images" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "images" } } message_type { name: "DeleteImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } service { name: "Images" method { name: "Get" input_type: ".containerd.services.images.v1.GetImageRequest" output_type: ".containerd.services.images.v1.GetImageResponse" } method { name: "List" input_type: ".containerd.services.images.v1.ListImagesRequest" output_type: ".containerd.services.images.v1.ListImagesResponse" } method { name: "Create" input_type: ".containerd.services.images.v1.CreateImageRequest" output_type: ".containerd.services.images.v1.CreateImageResponse" } method { name: "Update" input_type: ".containerd.services.images.v1.UpdateImageRequest" output_type: ".containerd.services.images.v1.UpdateImageResponse" } method { name: "Delete" input_type: ".containerd.services.images.v1.DeleteImageRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/images/v1;images" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/platform.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Platform" field { name: "os" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65004: "OS" } json_name: "os" } field { name: "architecture" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "architecture" } field { name: "variant" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "variant" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "google/rpc/status.proto" package: "google.rpc" dependency: "google/protobuf/any.proto" message_type { name: "Status" field { name: "code" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "code" } field { name: "message" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "message" } field { name: "details" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "details" } } options { java_package: "com.google.rpc" java_outer_classname: "StatusProto" java_multiple_files: true go_package: "github.com/containerd/containerd/protobuf/google/rpc;rpc" objc_class_prefix: "RPC" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/introspection/v1/introspection.proto" package: "containerd.services.introspection.v1" dependency: "github.com/containerd/containerd/api/types/platform.proto" dependency: "google/rpc/status.proto" dependency: "gogoproto/gogo.proto" message_type { name: "Plugin" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "requires" number: 3 label: LABEL_REPEATED type: TYPE_STRING json_name: "requires" } field { name: "platforms" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Platform" options { 65001: 0 } json_name: "platforms" } field { name: "exports" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin.ExportsEntry" json_name: "exports" } field { name: "capabilities" number: 6 label: LABEL_REPEATED type: TYPE_STRING json_name: "capabilities" } field { name: "init_err" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.rpc.Status" json_name: "initErr" } nested_type { name: "ExportsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PluginsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "PluginsResponse" field { name: "plugins" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin" options { 65001: 0 } json_name: "plugins" } } service { name: "Introspection" method { name: "Plugins" input_type: ".containerd.services.introspection.v1.PluginsRequest" output_type: ".containerd.services.introspection.v1.PluginsResponse" } } options { go_package: "github.com/containerd/containerd/api/services/introspection/v1;introspection" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/leases/v1/leases.proto" package: "containerd.services.leases.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Lease" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "created_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.CreateRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateResponse" field { name: "lease" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "lease" } } message_type { name: "DeleteRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "ListRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListResponse" field { name: "leases" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "leases" } } service { name: "Leases" method { name: "Create" input_type: ".containerd.services.leases.v1.CreateRequest" output_type: ".containerd.services.leases.v1.CreateResponse" } method { name: "Delete" input_type: ".containerd.services.leases.v1.DeleteRequest" output_type: ".google.protobuf.Empty" } method { name: "List" input_type: ".containerd.services.leases.v1.ListRequest" output_type: ".containerd.services.leases.v1.ListResponse" } } options { go_package: "github.com/containerd/containerd/api/services/leases/v1;leases" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto" package: "containerd.services.namespaces.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" message_type { name: "Namespace" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "ListNamespacesRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListNamespacesResponse" field { name: "namespaces" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespaces" } } message_type { name: "CreateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "CreateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "UpdateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "DeleteNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } service { name: "Namespaces" method { name: "Get" input_type: ".containerd.services.namespaces.v1.GetNamespaceRequest" output_type: ".containerd.services.namespaces.v1.GetNamespaceResponse" } method { name: "List" input_type: ".containerd.services.namespaces.v1.ListNamespacesRequest" output_type: ".containerd.services.namespaces.v1.ListNamespacesResponse" } method { name: "Create" input_type: ".containerd.services.namespaces.v1.CreateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.CreateNamespaceResponse" } method { name: "Update" input_type: ".containerd.services.namespaces.v1.UpdateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.UpdateNamespaceResponse" } method { name: "Delete" input_type: ".containerd.services.namespaces.v1.DeleteNamespaceRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/namespaces/v1;namespaces" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto" package: "containerd.services.snapshots.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" message_type { name: "PrepareSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.PrepareSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PrepareSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ViewSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.ViewSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ViewSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "MountsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "MountsResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "RemoveSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "CommitSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "key" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.CommitSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "Info" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "kind" number: 3 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.snapshots.v1.Kind" json_name: "kind" } field { name: "created_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "labels" number: 6 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListSnapshotsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } } message_type { name: "ListSnapshotsResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UsageRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "UsageResponse" field { name: "size" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "inodes" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "inodes" } } enum_type { name: "Kind" value { name: "UNKNOWN" number: 0 options { 66001: "KindUnknown" } } value { name: "VIEW" number: 1 options { 66001: "KindView" } } value { name: "ACTIVE" number: 2 options { 66001: "KindActive" } } value { name: "COMMITTED" number: 3 options { 66001: "KindCommitted" } } options { 62001: 0 62023: "Kind" } } service { name: "Snapshots" method { name: "Prepare" input_type: ".containerd.services.snapshots.v1.PrepareSnapshotRequest" output_type: ".containerd.services.snapshots.v1.PrepareSnapshotResponse" } method { name: "View" input_type: ".containerd.services.snapshots.v1.ViewSnapshotRequest" output_type: ".containerd.services.snapshots.v1.ViewSnapshotResponse" } method { name: "Mounts" input_type: ".containerd.services.snapshots.v1.MountsRequest" output_type: ".containerd.services.snapshots.v1.MountsResponse" } method { name: "Commit" input_type: ".containerd.services.snapshots.v1.CommitSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Remove" input_type: ".containerd.services.snapshots.v1.RemoveSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Stat" input_type: ".containerd.services.snapshots.v1.StatSnapshotRequest" output_type: ".containerd.services.snapshots.v1.StatSnapshotResponse" } method { name: "Update" input_type: ".containerd.services.snapshots.v1.UpdateSnapshotRequest" output_type: ".containerd.services.snapshots.v1.UpdateSnapshotResponse" } method { name: "List" input_type: ".containerd.services.snapshots.v1.ListSnapshotsRequest" output_type: ".containerd.services.snapshots.v1.ListSnapshotsResponse" server_streaming: true } method { name: "Usage" input_type: ".containerd.services.snapshots.v1.UsageRequest" output_type: ".containerd.services.snapshots.v1.UsageResponse" } } options { go_package: "github.com/containerd/containerd/api/services/snapshots/v1;snapshots" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/metrics.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Metric" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "timestamp" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "data" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "data" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/task/task.proto" package: "containerd.v1.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/any.proto" message_type { name: "Process" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "status" number: 4 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.v1.types.Status" json_name: "status" } field { name: "stdin" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 8 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "exit_status" number: 9 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 10 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "ProcessInfo" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "info" } } enum_type { name: "Status" value { name: "UNKNOWN" number: 0 options { 66001: "StatusUnknown" } } value { name: "CREATED" number: 1 options { 66001: "StatusCreated" } } value { name: "RUNNING" number: 2 options { 66001: "StatusRunning" } } value { name: "STOPPED" number: 3 options { 66001: "StatusStopped" } } value { name: "PAUSED" number: 4 options { 66001: "StatusPaused" } } value { name: "PAUSING" number: 5 options { 66001: "StatusPausing" } } options { 62001: 0 62023: "Status" } } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto" package: "containerd.services.tasks.v1" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/metrics.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" dependency: "github.com/containerd/containerd/api/types/task/task.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "CreateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "stdin" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 7 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "checkpoint" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "checkpoint" } field { name: "options" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CreateTaskResponse" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "StartRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "StartResponse" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "DeleteTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "DeleteResponse" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "DeleteProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetResponse" field { name: "process" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "process" } } message_type { name: "ListTasksRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListTasksResponse" field { name: "tasks" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "tasks" } } message_type { name: "KillRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "signal" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "signal" } field { name: "all" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "all" } } message_type { name: "ExecProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "stdin" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 5 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "spec" number: 6 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "exec_id" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "ExecProcessResponse" } message_type { name: "ResizePtyRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "width" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "width" } field { name: "height" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "height" } } message_type { name: "CloseIORequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "stdin" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "stdin" } } message_type { name: "PauseTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ResumeTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsResponse" field { name: "processes" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.ProcessInfo" json_name: "processes" } } message_type { name: "CheckpointTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "parent_checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "parentCheckpoint" } field { name: "options" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CheckpointTaskResponse" field { name: "descriptors" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "descriptors" } } message_type { name: "UpdateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "resources" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "resources" } } message_type { name: "MetricsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "MetricsResponse" field { name: "metrics" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Metric" json_name: "metrics" } } message_type { name: "WaitRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "WaitResponse" field { name: "exit_status" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } service { name: "Tasks" method { name: "Create" input_type: ".containerd.services.tasks.v1.CreateTaskRequest" output_type: ".containerd.services.tasks.v1.CreateTaskResponse" } method { name: "Start" input_type: ".containerd.services.tasks.v1.StartRequest" output_type: ".containerd.services.tasks.v1.StartResponse" } method { name: "Delete" input_type: ".containerd.services.tasks.v1.DeleteTaskRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "DeleteProcess" input_type: ".containerd.services.tasks.v1.DeleteProcessRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "Get" input_type: ".containerd.services.tasks.v1.GetRequest" output_type: ".containerd.services.tasks.v1.GetResponse" } method { name: "List" input_type: ".containerd.services.tasks.v1.ListTasksRequest" output_type: ".containerd.services.tasks.v1.ListTasksResponse" } method { name: "Kill" input_type: ".containerd.services.tasks.v1.KillRequest" output_type: ".google.protobuf.Empty" } method { name: "Exec" input_type: ".containerd.services.tasks.v1.ExecProcessRequest" output_type: ".google.protobuf.Empty" } method { name: "ResizePty" input_type: ".containerd.services.tasks.v1.ResizePtyRequest" output_type: ".google.protobuf.Empty" } method { name: "CloseIO" input_type: ".containerd.services.tasks.v1.CloseIORequest" output_type: ".google.protobuf.Empty" } method { name: "Pause" input_type: ".containerd.services.tasks.v1.PauseTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Resume" input_type: ".containerd.services.tasks.v1.ResumeTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "ListPids" input_type: ".containerd.services.tasks.v1.ListPidsRequest" output_type: ".containerd.services.tasks.v1.ListPidsResponse" } method { name: "Checkpoint" input_type: ".containerd.services.tasks.v1.CheckpointTaskRequest" output_type: ".containerd.services.tasks.v1.CheckpointTaskResponse" } method { name: "Update" input_type: ".containerd.services.tasks.v1.UpdateTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Metrics" input_type: ".containerd.services.tasks.v1.MetricsRequest" output_type: ".containerd.services.tasks.v1.MetricsResponse" } method { name: "Wait" input_type: ".containerd.services.tasks.v1.WaitRequest" output_type: ".containerd.services.tasks.v1.WaitResponse" } } options { go_package: "github.com/containerd/containerd/api/services/tasks/v1;tasks" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/version/v1/version.proto" package: "containerd.services.version.v1" dependency: "google/protobuf/empty.proto" dependency: "gogoproto/gogo.proto" message_type { name: "VersionResponse" field { name: "version" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "version" } field { name: "revision" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "revision" } } service { name: "Version" method { name: "Version" input_type: ".google.protobuf.Empty" output_type: ".containerd.services.version.v1.VersionResponse" } } options { go_package: "github.com/containerd/containerd/api/services/version/v1;version" } weak_dependency: 1 syntax: "proto3" } containerd-1.5.9/api/1.1.pb.txt000066400000000000000000002617211416535272200161050ustar00rootroot00000000000000file { name: "google/protobuf/any.proto" package: "google.protobuf" message_type { name: "Any" field { name: "type_url" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "typeUrl" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "value" } } options { java_package: "com.google.protobuf" java_outer_classname: "AnyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/any" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" package: "containerd.plugin" dependency: "google/protobuf/descriptor.proto" extension { name: "fieldpath_all" extendee: ".google.protobuf.FileOptions" number: 63300 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpathAll" } extension { name: "fieldpath" extendee: ".google.protobuf.MessageOptions" number: 64400 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpath" } } file { name: "github.com/containerd/containerd/api/events/container.proto" package: "containerd.events" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContainerCreate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.ContainerCreate.Runtime" json_name: "runtime" } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } } message_type { name: "ContainerUpdate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.ContainerUpdate.LabelsEntry" json_name: "labels" } field { name: "snapshot_key" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ContainerDelete" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 1 weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/content.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContentDelete" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/image.proto" package: "containerd.services.images.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ImageCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/namespace.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "NamespaceCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/snapshot.proto" package: "containerd.events" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "SnapshotPrepare" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } } message_type { name: "SnapshotCommit" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "SnapshotRemove" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "google/protobuf/timestamp.proto" package: "google.protobuf" message_type { name: "Timestamp" field { name: "seconds" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "seconds" } field { name: "nanos" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "nanos" } } options { java_package: "com.google.protobuf" java_outer_classname: "TimestampProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/timestamp" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/mount.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Mount" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "source" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "source" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "target" } field { name: "options" number: 4 label: LABEL_REPEATED type: TYPE_STRING json_name: "options" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/task.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "TaskCreate" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "bundle" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "bundle" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "io" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.TaskIO" options { 65004: "IO" } json_name: "io" } field { name: "checkpoint" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } field { name: "pid" number: 6 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskStart" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskDelete" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "TaskIO" field { name: "stdin" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } } message_type { name: "TaskExit" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "TaskOOM" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskExecAdded" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "TaskExecStarted" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskPaused" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskResumed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskCheckpointed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 3 syntax: "proto3" } file { name: "google/protobuf/empty.proto" package: "google.protobuf" message_type { name: "Empty" } options { java_package: "com.google.protobuf" java_outer_classname: "EmptyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/empty" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "google/protobuf/field_mask.proto" package: "google.protobuf" message_type { name: "FieldMask" field { name: "paths" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "paths" } } options { java_package: "com.google.protobuf" java_outer_classname: "FieldMaskProto" java_multiple_files: true go_package: "google.golang.org/genproto/protobuf/field_mask;field_mask" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/containers/v1/containers.proto" package: "containerd.services.containers.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Container" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.LabelsEntry" json_name: "labels" } field { name: "image" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.Runtime" json_name: "runtime" } field { name: "spec" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "snapshotter" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "snapshot_key" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } field { name: "created_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "extensions" number: 10 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.ExtensionsEntry" options { 65001: 0 } json_name: "extensions" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } nested_type { name: "ExtensionsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "value" } options { map_entry: true } } } message_type { name: "GetContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "GetContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "ListContainersRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContainersResponse" field { name: "containers" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "containers" } } message_type { name: "CreateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "CreateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "UpdateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "DeleteContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } service { name: "Containers" method { name: "Get" input_type: ".containerd.services.containers.v1.GetContainerRequest" output_type: ".containerd.services.containers.v1.GetContainerResponse" } method { name: "List" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainersResponse" } method { name: "Create" input_type: ".containerd.services.containers.v1.CreateContainerRequest" output_type: ".containerd.services.containers.v1.CreateContainerResponse" } method { name: "Update" input_type: ".containerd.services.containers.v1.UpdateContainerRequest" output_type: ".containerd.services.containers.v1.UpdateContainerResponse" } method { name: "Delete" input_type: ".containerd.services.containers.v1.DeleteContainerRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/containers/v1;containers" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/content/v1/content.proto" package: "containerd.services.content.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/empty.proto" message_type { name: "Info" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "size" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "created_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "InfoRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "InfoResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateRequest" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListContentRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContentResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "DeleteContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "ReadContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "offset" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } message_type { name: "ReadContentResponse" field { name: "offset" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } } message_type { name: "Status" field { name: "started_at" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "startedAt" } field { name: "updated_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "ref" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "expected" } } message_type { name: "StatusRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } message_type { name: "StatusResponse" field { name: "status" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" json_name: "status" } } message_type { name: "ListStatusesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListStatusesResponse" field { name: "statuses" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" options { 65001: 0 } json_name: "statuses" } } message_type { name: "WriteContentRequest" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "ref" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "total" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "expected" } field { name: "offset" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 6 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } field { name: "labels" number: 7 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.WriteContentRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "WriteContentResponse" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "started_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "startedAt" } field { name: "updated_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "digest" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } } message_type { name: "AbortRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } enum_type { name: "WriteAction" value { name: "STAT" number: 0 options { 66001: "WriteActionStat" } } value { name: "WRITE" number: 1 options { 66001: "WriteActionWrite" } } value { name: "COMMIT" number: 2 options { 66001: "WriteActionCommit" } } options { 62001: 0 62023: "WriteAction" } } service { name: "Content" method { name: "Info" input_type: ".containerd.services.content.v1.InfoRequest" output_type: ".containerd.services.content.v1.InfoResponse" } method { name: "Update" input_type: ".containerd.services.content.v1.UpdateRequest" output_type: ".containerd.services.content.v1.UpdateResponse" } method { name: "List" input_type: ".containerd.services.content.v1.ListContentRequest" output_type: ".containerd.services.content.v1.ListContentResponse" server_streaming: true } method { name: "Delete" input_type: ".containerd.services.content.v1.DeleteContentRequest" output_type: ".google.protobuf.Empty" } method { name: "Read" input_type: ".containerd.services.content.v1.ReadContentRequest" output_type: ".containerd.services.content.v1.ReadContentResponse" server_streaming: true } method { name: "Status" input_type: ".containerd.services.content.v1.StatusRequest" output_type: ".containerd.services.content.v1.StatusResponse" } method { name: "ListStatuses" input_type: ".containerd.services.content.v1.ListStatusesRequest" output_type: ".containerd.services.content.v1.ListStatusesResponse" } method { name: "Write" input_type: ".containerd.services.content.v1.WriteContentRequest" output_type: ".containerd.services.content.v1.WriteContentResponse" client_streaming: true server_streaming: true } method { name: "Abort" input_type: ".containerd.services.content.v1.AbortRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/content/v1;content" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/descriptor.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Descriptor" field { name: "media_type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "digest" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "digest" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/diff/v1/diff.proto" package: "containerd.services.diff.v1" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "ApplyRequest" field { name: "diff" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } field { name: "mounts" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ApplyResponse" field { name: "applied" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "applied" } } message_type { name: "DiffRequest" field { name: "left" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "left" } field { name: "right" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "right" } field { name: "media_type" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "ref" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.diff.v1.DiffRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "DiffResponse" field { name: "diff" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } } service { name: "Diff" method { name: "Apply" input_type: ".containerd.services.diff.v1.ApplyRequest" output_type: ".containerd.services.diff.v1.ApplyResponse" } method { name: "Diff" input_type: ".containerd.services.diff.v1.DiffRequest" output_type: ".containerd.services.diff.v1.DiffResponse" } } options { go_package: "github.com/containerd/containerd/api/services/diff/v1;diff" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/events/v1/events.proto" package: "containerd.services.events.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "PublishRequest" field { name: "topic" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } } message_type { name: "ForwardRequest" field { name: "envelope" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.events.v1.Envelope" json_name: "envelope" } } message_type { name: "SubscribeRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "Envelope" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "timestamp" } field { name: "namespace" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "namespace" } field { name: "topic" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } options { 64400: 1 } } service { name: "Events" method { name: "Publish" input_type: ".containerd.services.events.v1.PublishRequest" output_type: ".google.protobuf.Empty" } method { name: "Forward" input_type: ".containerd.services.events.v1.ForwardRequest" output_type: ".google.protobuf.Empty" } method { name: "Subscribe" input_type: ".containerd.services.events.v1.SubscribeRequest" output_type: ".containerd.services.events.v1.Envelope" server_streaming: true } } options { go_package: "github.com/containerd/containerd/api/services/events/v1;events" } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/images/v1/images.proto" package: "containerd.services.images.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "Image" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image.LabelsEntry" json_name: "labels" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" options { 65001: 0 } json_name: "target" } field { name: "created_at" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" json_name: "image" } } message_type { name: "CreateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "CreateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "UpdateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "ListImagesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListImagesResponse" field { name: "images" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "images" } } message_type { name: "DeleteImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } service { name: "Images" method { name: "Get" input_type: ".containerd.services.images.v1.GetImageRequest" output_type: ".containerd.services.images.v1.GetImageResponse" } method { name: "List" input_type: ".containerd.services.images.v1.ListImagesRequest" output_type: ".containerd.services.images.v1.ListImagesResponse" } method { name: "Create" input_type: ".containerd.services.images.v1.CreateImageRequest" output_type: ".containerd.services.images.v1.CreateImageResponse" } method { name: "Update" input_type: ".containerd.services.images.v1.UpdateImageRequest" output_type: ".containerd.services.images.v1.UpdateImageResponse" } method { name: "Delete" input_type: ".containerd.services.images.v1.DeleteImageRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/images/v1;images" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/platform.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Platform" field { name: "os" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65004: "OS" } json_name: "os" } field { name: "architecture" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "architecture" } field { name: "variant" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "variant" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "google/rpc/status.proto" package: "google.rpc" dependency: "google/protobuf/any.proto" message_type { name: "Status" field { name: "code" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "code" } field { name: "message" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "message" } field { name: "details" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "details" } } options { java_package: "com.google.rpc" java_outer_classname: "StatusProto" java_multiple_files: true go_package: "rpc" objc_class_prefix: "RPC" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/introspection/v1/introspection.proto" package: "containerd.services.introspection.v1" dependency: "github.com/containerd/containerd/api/types/platform.proto" dependency: "google/rpc/status.proto" dependency: "gogoproto/gogo.proto" message_type { name: "Plugin" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "requires" number: 3 label: LABEL_REPEATED type: TYPE_STRING json_name: "requires" } field { name: "platforms" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Platform" options { 65001: 0 } json_name: "platforms" } field { name: "exports" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin.ExportsEntry" json_name: "exports" } field { name: "capabilities" number: 6 label: LABEL_REPEATED type: TYPE_STRING json_name: "capabilities" } field { name: "init_err" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.rpc.Status" json_name: "initErr" } nested_type { name: "ExportsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PluginsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "PluginsResponse" field { name: "plugins" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin" options { 65001: 0 } json_name: "plugins" } } service { name: "Introspection" method { name: "Plugins" input_type: ".containerd.services.introspection.v1.PluginsRequest" output_type: ".containerd.services.introspection.v1.PluginsResponse" } } options { go_package: "github.com/containerd/containerd/api/services/introspection/v1;introspection" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/leases/v1/leases.proto" package: "containerd.services.leases.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Lease" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "created_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.CreateRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateResponse" field { name: "lease" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "lease" } } message_type { name: "DeleteRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "ListRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListResponse" field { name: "leases" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "leases" } } service { name: "Leases" method { name: "Create" input_type: ".containerd.services.leases.v1.CreateRequest" output_type: ".containerd.services.leases.v1.CreateResponse" } method { name: "Delete" input_type: ".containerd.services.leases.v1.DeleteRequest" output_type: ".google.protobuf.Empty" } method { name: "List" input_type: ".containerd.services.leases.v1.ListRequest" output_type: ".containerd.services.leases.v1.ListResponse" } } options { go_package: "github.com/containerd/containerd/api/services/leases/v1;leases" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto" package: "containerd.services.namespaces.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" message_type { name: "Namespace" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "ListNamespacesRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListNamespacesResponse" field { name: "namespaces" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespaces" } } message_type { name: "CreateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "CreateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "UpdateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "DeleteNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } service { name: "Namespaces" method { name: "Get" input_type: ".containerd.services.namespaces.v1.GetNamespaceRequest" output_type: ".containerd.services.namespaces.v1.GetNamespaceResponse" } method { name: "List" input_type: ".containerd.services.namespaces.v1.ListNamespacesRequest" output_type: ".containerd.services.namespaces.v1.ListNamespacesResponse" } method { name: "Create" input_type: ".containerd.services.namespaces.v1.CreateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.CreateNamespaceResponse" } method { name: "Update" input_type: ".containerd.services.namespaces.v1.UpdateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.UpdateNamespaceResponse" } method { name: "Delete" input_type: ".containerd.services.namespaces.v1.DeleteNamespaceRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/namespaces/v1;namespaces" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto" package: "containerd.services.snapshots.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" message_type { name: "PrepareSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.PrepareSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PrepareSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ViewSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.ViewSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ViewSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "MountsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "MountsResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "RemoveSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "CommitSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "key" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.CommitSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "Info" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "kind" number: 3 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.snapshots.v1.Kind" json_name: "kind" } field { name: "created_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "createdAt" } field { name: "updated_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "updatedAt" } field { name: "labels" number: 6 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListSnapshotsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } } message_type { name: "ListSnapshotsResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UsageRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "UsageResponse" field { name: "size" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "inodes" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "inodes" } } enum_type { name: "Kind" value { name: "UNKNOWN" number: 0 options { 66001: "KindUnknown" } } value { name: "VIEW" number: 1 options { 66001: "KindView" } } value { name: "ACTIVE" number: 2 options { 66001: "KindActive" } } value { name: "COMMITTED" number: 3 options { 66001: "KindCommitted" } } options { 62001: 0 62023: "Kind" } } service { name: "Snapshots" method { name: "Prepare" input_type: ".containerd.services.snapshots.v1.PrepareSnapshotRequest" output_type: ".containerd.services.snapshots.v1.PrepareSnapshotResponse" } method { name: "View" input_type: ".containerd.services.snapshots.v1.ViewSnapshotRequest" output_type: ".containerd.services.snapshots.v1.ViewSnapshotResponse" } method { name: "Mounts" input_type: ".containerd.services.snapshots.v1.MountsRequest" output_type: ".containerd.services.snapshots.v1.MountsResponse" } method { name: "Commit" input_type: ".containerd.services.snapshots.v1.CommitSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Remove" input_type: ".containerd.services.snapshots.v1.RemoveSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Stat" input_type: ".containerd.services.snapshots.v1.StatSnapshotRequest" output_type: ".containerd.services.snapshots.v1.StatSnapshotResponse" } method { name: "Update" input_type: ".containerd.services.snapshots.v1.UpdateSnapshotRequest" output_type: ".containerd.services.snapshots.v1.UpdateSnapshotResponse" } method { name: "List" input_type: ".containerd.services.snapshots.v1.ListSnapshotsRequest" output_type: ".containerd.services.snapshots.v1.ListSnapshotsResponse" server_streaming: true } method { name: "Usage" input_type: ".containerd.services.snapshots.v1.UsageRequest" output_type: ".containerd.services.snapshots.v1.UsageResponse" } } options { go_package: "github.com/containerd/containerd/api/services/snapshots/v1;snapshots" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/metrics.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Metric" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "timestamp" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "data" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "data" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/task/task.proto" package: "containerd.v1.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/any.proto" message_type { name: "Process" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "status" number: 4 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.v1.types.Status" json_name: "status" } field { name: "stdin" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 8 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "exit_status" number: 9 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 10 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "ProcessInfo" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "info" } } enum_type { name: "Status" value { name: "UNKNOWN" number: 0 options { 66001: "StatusUnknown" } } value { name: "CREATED" number: 1 options { 66001: "StatusCreated" } } value { name: "RUNNING" number: 2 options { 66001: "StatusRunning" } } value { name: "STOPPED" number: 3 options { 66001: "StatusStopped" } } value { name: "PAUSED" number: 4 options { 66001: "StatusPaused" } } value { name: "PAUSING" number: 5 options { 66001: "StatusPausing" } } options { 62001: 0 62023: "Status" } } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto" package: "containerd.services.tasks.v1" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/metrics.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" dependency: "github.com/containerd/containerd/api/types/task/task.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "CreateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "stdin" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 7 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "checkpoint" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "checkpoint" } field { name: "options" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CreateTaskResponse" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "StartRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "StartResponse" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "DeleteTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "DeleteResponse" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } message_type { name: "DeleteProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetResponse" field { name: "process" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "process" } } message_type { name: "ListTasksRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListTasksResponse" field { name: "tasks" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "tasks" } } message_type { name: "KillRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "signal" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "signal" } field { name: "all" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "all" } } message_type { name: "ExecProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "stdin" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 5 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "spec" number: 6 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "exec_id" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "ExecProcessResponse" } message_type { name: "ResizePtyRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "width" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "width" } field { name: "height" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "height" } } message_type { name: "CloseIORequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "stdin" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "stdin" } } message_type { name: "PauseTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ResumeTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsResponse" field { name: "processes" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.ProcessInfo" json_name: "processes" } } message_type { name: "CheckpointTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "parent_checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65003: "github.com/opencontainers/go-digest.Digest" 65001: 0 } json_name: "parentCheckpoint" } field { name: "options" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CheckpointTaskResponse" field { name: "descriptors" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "descriptors" } } message_type { name: "UpdateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "resources" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "resources" } } message_type { name: "MetricsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "MetricsResponse" field { name: "metrics" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Metric" json_name: "metrics" } } message_type { name: "WaitRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "WaitResponse" field { name: "exit_status" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65010: 1 65001: 0 } json_name: "exitedAt" } } service { name: "Tasks" method { name: "Create" input_type: ".containerd.services.tasks.v1.CreateTaskRequest" output_type: ".containerd.services.tasks.v1.CreateTaskResponse" } method { name: "Start" input_type: ".containerd.services.tasks.v1.StartRequest" output_type: ".containerd.services.tasks.v1.StartResponse" } method { name: "Delete" input_type: ".containerd.services.tasks.v1.DeleteTaskRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "DeleteProcess" input_type: ".containerd.services.tasks.v1.DeleteProcessRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "Get" input_type: ".containerd.services.tasks.v1.GetRequest" output_type: ".containerd.services.tasks.v1.GetResponse" } method { name: "List" input_type: ".containerd.services.tasks.v1.ListTasksRequest" output_type: ".containerd.services.tasks.v1.ListTasksResponse" } method { name: "Kill" input_type: ".containerd.services.tasks.v1.KillRequest" output_type: ".google.protobuf.Empty" } method { name: "Exec" input_type: ".containerd.services.tasks.v1.ExecProcessRequest" output_type: ".google.protobuf.Empty" } method { name: "ResizePty" input_type: ".containerd.services.tasks.v1.ResizePtyRequest" output_type: ".google.protobuf.Empty" } method { name: "CloseIO" input_type: ".containerd.services.tasks.v1.CloseIORequest" output_type: ".google.protobuf.Empty" } method { name: "Pause" input_type: ".containerd.services.tasks.v1.PauseTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Resume" input_type: ".containerd.services.tasks.v1.ResumeTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "ListPids" input_type: ".containerd.services.tasks.v1.ListPidsRequest" output_type: ".containerd.services.tasks.v1.ListPidsResponse" } method { name: "Checkpoint" input_type: ".containerd.services.tasks.v1.CheckpointTaskRequest" output_type: ".containerd.services.tasks.v1.CheckpointTaskResponse" } method { name: "Update" input_type: ".containerd.services.tasks.v1.UpdateTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Metrics" input_type: ".containerd.services.tasks.v1.MetricsRequest" output_type: ".containerd.services.tasks.v1.MetricsResponse" } method { name: "Wait" input_type: ".containerd.services.tasks.v1.WaitRequest" output_type: ".containerd.services.tasks.v1.WaitResponse" } } options { go_package: "github.com/containerd/containerd/api/services/tasks/v1;tasks" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/version/v1/version.proto" package: "containerd.services.version.v1" dependency: "google/protobuf/empty.proto" dependency: "gogoproto/gogo.proto" message_type { name: "VersionResponse" field { name: "version" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "version" } field { name: "revision" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "revision" } } service { name: "Version" method { name: "Version" input_type: ".google.protobuf.Empty" output_type: ".containerd.services.version.v1.VersionResponse" } } options { go_package: "github.com/containerd/containerd/api/services/version/v1;version" } weak_dependency: 1 syntax: "proto3" } containerd-1.5.9/api/1.2.pb.txt000066400000000000000000002630651416535272200161110ustar00rootroot00000000000000file { name: "google/protobuf/any.proto" package: "google.protobuf" message_type { name: "Any" field { name: "type_url" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "typeUrl" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "value" } } options { java_package: "com.google.protobuf" java_outer_classname: "AnyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/any" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" package: "containerd.plugin" dependency: "google/protobuf/descriptor.proto" extension { name: "fieldpath_all" extendee: ".google.protobuf.FileOptions" number: 63300 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpathAll" } extension { name: "fieldpath" extendee: ".google.protobuf.MessageOptions" number: 64400 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpath" } } file { name: "github.com/containerd/containerd/api/events/container.proto" package: "containerd.events" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContainerCreate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.ContainerCreate.Runtime" json_name: "runtime" } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } } message_type { name: "ContainerUpdate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.ContainerUpdate.LabelsEntry" json_name: "labels" } field { name: "snapshot_key" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ContainerDelete" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 1 weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/content.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContentDelete" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/image.proto" package: "containerd.services.images.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ImageCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/namespace.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "NamespaceCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/snapshot.proto" package: "containerd.events" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "SnapshotPrepare" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } } message_type { name: "SnapshotCommit" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "SnapshotRemove" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "google/protobuf/timestamp.proto" package: "google.protobuf" message_type { name: "Timestamp" field { name: "seconds" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "seconds" } field { name: "nanos" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "nanos" } } options { java_package: "com.google.protobuf" java_outer_classname: "TimestampProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/timestamp" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/mount.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Mount" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "source" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "source" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "target" } field { name: "options" number: 4 label: LABEL_REPEATED type: TYPE_STRING json_name: "options" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/task.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "TaskCreate" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "bundle" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "bundle" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "io" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.TaskIO" options { 65004: "IO" } json_name: "io" } field { name: "checkpoint" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } field { name: "pid" number: 6 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskStart" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskDelete" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "TaskIO" field { name: "stdin" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } } message_type { name: "TaskExit" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "TaskOOM" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskExecAdded" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "TaskExecStarted" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskPaused" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskResumed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskCheckpointed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 3 syntax: "proto3" } file { name: "google/protobuf/empty.proto" package: "google.protobuf" message_type { name: "Empty" } options { java_package: "com.google.protobuf" java_outer_classname: "EmptyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/empty" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "google/protobuf/field_mask.proto" package: "google.protobuf" message_type { name: "FieldMask" field { name: "paths" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "paths" } } options { java_package: "com.google.protobuf" java_outer_classname: "FieldMaskProto" java_multiple_files: true go_package: "google.golang.org/genproto/protobuf/field_mask;field_mask" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/containers/v1/containers.proto" package: "containerd.services.containers.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Container" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.LabelsEntry" json_name: "labels" } field { name: "image" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.Runtime" json_name: "runtime" } field { name: "spec" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "snapshotter" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "snapshot_key" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } field { name: "created_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "extensions" number: 10 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.ExtensionsEntry" options { 65001: 0 } json_name: "extensions" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } nested_type { name: "ExtensionsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "value" } options { map_entry: true } } } message_type { name: "GetContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "GetContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "ListContainersRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContainersResponse" field { name: "containers" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "containers" } } message_type { name: "CreateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "CreateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "UpdateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "DeleteContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "ListContainerMessage" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" json_name: "container" } } service { name: "Containers" method { name: "Get" input_type: ".containerd.services.containers.v1.GetContainerRequest" output_type: ".containerd.services.containers.v1.GetContainerResponse" } method { name: "List" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainersResponse" } method { name: "ListStream" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainerMessage" server_streaming: true } method { name: "Create" input_type: ".containerd.services.containers.v1.CreateContainerRequest" output_type: ".containerd.services.containers.v1.CreateContainerResponse" } method { name: "Update" input_type: ".containerd.services.containers.v1.UpdateContainerRequest" output_type: ".containerd.services.containers.v1.UpdateContainerResponse" } method { name: "Delete" input_type: ".containerd.services.containers.v1.DeleteContainerRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/containers/v1;containers" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/content/v1/content.proto" package: "containerd.services.content.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/empty.proto" message_type { name: "Info" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "size" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "created_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "InfoRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "InfoResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateRequest" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListContentRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContentResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "DeleteContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "ReadContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "offset" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } message_type { name: "ReadContentResponse" field { name: "offset" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } } message_type { name: "Status" field { name: "started_at" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "startedAt" } field { name: "updated_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "ref" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "expected" } } message_type { name: "StatusRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } message_type { name: "StatusResponse" field { name: "status" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" json_name: "status" } } message_type { name: "ListStatusesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListStatusesResponse" field { name: "statuses" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" options { 65001: 0 } json_name: "statuses" } } message_type { name: "WriteContentRequest" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "ref" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "total" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "expected" } field { name: "offset" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 6 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } field { name: "labels" number: 7 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.WriteContentRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "WriteContentResponse" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "started_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "startedAt" } field { name: "updated_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "digest" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "AbortRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } enum_type { name: "WriteAction" value { name: "STAT" number: 0 options { 66001: "WriteActionStat" } } value { name: "WRITE" number: 1 options { 66001: "WriteActionWrite" } } value { name: "COMMIT" number: 2 options { 66001: "WriteActionCommit" } } options { 62001: 0 62023: "WriteAction" } } service { name: "Content" method { name: "Info" input_type: ".containerd.services.content.v1.InfoRequest" output_type: ".containerd.services.content.v1.InfoResponse" } method { name: "Update" input_type: ".containerd.services.content.v1.UpdateRequest" output_type: ".containerd.services.content.v1.UpdateResponse" } method { name: "List" input_type: ".containerd.services.content.v1.ListContentRequest" output_type: ".containerd.services.content.v1.ListContentResponse" server_streaming: true } method { name: "Delete" input_type: ".containerd.services.content.v1.DeleteContentRequest" output_type: ".google.protobuf.Empty" } method { name: "Read" input_type: ".containerd.services.content.v1.ReadContentRequest" output_type: ".containerd.services.content.v1.ReadContentResponse" server_streaming: true } method { name: "Status" input_type: ".containerd.services.content.v1.StatusRequest" output_type: ".containerd.services.content.v1.StatusResponse" } method { name: "ListStatuses" input_type: ".containerd.services.content.v1.ListStatusesRequest" output_type: ".containerd.services.content.v1.ListStatusesResponse" } method { name: "Write" input_type: ".containerd.services.content.v1.WriteContentRequest" output_type: ".containerd.services.content.v1.WriteContentResponse" client_streaming: true server_streaming: true } method { name: "Abort" input_type: ".containerd.services.content.v1.AbortRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/content/v1;content" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/descriptor.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Descriptor" field { name: "media_type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "digest" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/diff/v1/diff.proto" package: "containerd.services.diff.v1" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "ApplyRequest" field { name: "diff" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } field { name: "mounts" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ApplyResponse" field { name: "applied" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "applied" } } message_type { name: "DiffRequest" field { name: "left" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "left" } field { name: "right" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "right" } field { name: "media_type" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "ref" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.diff.v1.DiffRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "DiffResponse" field { name: "diff" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } } service { name: "Diff" method { name: "Apply" input_type: ".containerd.services.diff.v1.ApplyRequest" output_type: ".containerd.services.diff.v1.ApplyResponse" } method { name: "Diff" input_type: ".containerd.services.diff.v1.DiffRequest" output_type: ".containerd.services.diff.v1.DiffResponse" } } options { go_package: "github.com/containerd/containerd/api/services/diff/v1;diff" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/events/v1/events.proto" package: "containerd.services.events.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "PublishRequest" field { name: "topic" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } } message_type { name: "ForwardRequest" field { name: "envelope" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.events.v1.Envelope" json_name: "envelope" } } message_type { name: "SubscribeRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "Envelope" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "timestamp" } field { name: "namespace" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "namespace" } field { name: "topic" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } options { 64400: 1 } } service { name: "Events" method { name: "Publish" input_type: ".containerd.services.events.v1.PublishRequest" output_type: ".google.protobuf.Empty" } method { name: "Forward" input_type: ".containerd.services.events.v1.ForwardRequest" output_type: ".google.protobuf.Empty" } method { name: "Subscribe" input_type: ".containerd.services.events.v1.SubscribeRequest" output_type: ".containerd.services.events.v1.Envelope" server_streaming: true } } options { go_package: "github.com/containerd/containerd/api/services/events/v1;events" } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/images/v1/images.proto" package: "containerd.services.images.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "Image" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image.LabelsEntry" json_name: "labels" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" options { 65001: 0 } json_name: "target" } field { name: "created_at" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" json_name: "image" } } message_type { name: "CreateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "CreateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "UpdateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "ListImagesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListImagesResponse" field { name: "images" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "images" } } message_type { name: "DeleteImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } service { name: "Images" method { name: "Get" input_type: ".containerd.services.images.v1.GetImageRequest" output_type: ".containerd.services.images.v1.GetImageResponse" } method { name: "List" input_type: ".containerd.services.images.v1.ListImagesRequest" output_type: ".containerd.services.images.v1.ListImagesResponse" } method { name: "Create" input_type: ".containerd.services.images.v1.CreateImageRequest" output_type: ".containerd.services.images.v1.CreateImageResponse" } method { name: "Update" input_type: ".containerd.services.images.v1.UpdateImageRequest" output_type: ".containerd.services.images.v1.UpdateImageResponse" } method { name: "Delete" input_type: ".containerd.services.images.v1.DeleteImageRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/images/v1;images" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/platform.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Platform" field { name: "os" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65004: "OS" } json_name: "os" } field { name: "architecture" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "architecture" } field { name: "variant" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "variant" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "google/rpc/status.proto" package: "google.rpc" dependency: "google/protobuf/any.proto" message_type { name: "Status" field { name: "code" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "code" } field { name: "message" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "message" } field { name: "details" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "details" } } options { java_package: "com.google.rpc" java_outer_classname: "StatusProto" java_multiple_files: true go_package: "rpc" objc_class_prefix: "RPC" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/introspection/v1/introspection.proto" package: "containerd.services.introspection.v1" dependency: "github.com/containerd/containerd/api/types/platform.proto" dependency: "google/rpc/status.proto" dependency: "gogoproto/gogo.proto" message_type { name: "Plugin" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "requires" number: 3 label: LABEL_REPEATED type: TYPE_STRING json_name: "requires" } field { name: "platforms" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Platform" options { 65001: 0 } json_name: "platforms" } field { name: "exports" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin.ExportsEntry" json_name: "exports" } field { name: "capabilities" number: 6 label: LABEL_REPEATED type: TYPE_STRING json_name: "capabilities" } field { name: "init_err" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.rpc.Status" json_name: "initErr" } nested_type { name: "ExportsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PluginsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "PluginsResponse" field { name: "plugins" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin" options { 65001: 0 } json_name: "plugins" } } service { name: "Introspection" method { name: "Plugins" input_type: ".containerd.services.introspection.v1.PluginsRequest" output_type: ".containerd.services.introspection.v1.PluginsResponse" } } options { go_package: "github.com/containerd/containerd/api/services/introspection/v1;introspection" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/leases/v1/leases.proto" package: "containerd.services.leases.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Lease" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "created_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.CreateRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateResponse" field { name: "lease" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "lease" } } message_type { name: "DeleteRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } message_type { name: "ListRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListResponse" field { name: "leases" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "leases" } } service { name: "Leases" method { name: "Create" input_type: ".containerd.services.leases.v1.CreateRequest" output_type: ".containerd.services.leases.v1.CreateResponse" } method { name: "Delete" input_type: ".containerd.services.leases.v1.DeleteRequest" output_type: ".google.protobuf.Empty" } method { name: "List" input_type: ".containerd.services.leases.v1.ListRequest" output_type: ".containerd.services.leases.v1.ListResponse" } } options { go_package: "github.com/containerd/containerd/api/services/leases/v1;leases" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto" package: "containerd.services.namespaces.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" message_type { name: "Namespace" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "ListNamespacesRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListNamespacesResponse" field { name: "namespaces" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespaces" } } message_type { name: "CreateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "CreateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "UpdateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "DeleteNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } service { name: "Namespaces" method { name: "Get" input_type: ".containerd.services.namespaces.v1.GetNamespaceRequest" output_type: ".containerd.services.namespaces.v1.GetNamespaceResponse" } method { name: "List" input_type: ".containerd.services.namespaces.v1.ListNamespacesRequest" output_type: ".containerd.services.namespaces.v1.ListNamespacesResponse" } method { name: "Create" input_type: ".containerd.services.namespaces.v1.CreateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.CreateNamespaceResponse" } method { name: "Update" input_type: ".containerd.services.namespaces.v1.UpdateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.UpdateNamespaceResponse" } method { name: "Delete" input_type: ".containerd.services.namespaces.v1.DeleteNamespaceRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/namespaces/v1;namespaces" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto" package: "containerd.services.snapshots.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" message_type { name: "PrepareSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.PrepareSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PrepareSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ViewSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.ViewSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ViewSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "MountsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "MountsResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "RemoveSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "CommitSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "key" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.CommitSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "Info" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "kind" number: 3 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.snapshots.v1.Kind" json_name: "kind" } field { name: "created_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "labels" number: 6 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListSnapshotsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } } message_type { name: "ListSnapshotsResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UsageRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "UsageResponse" field { name: "size" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "inodes" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "inodes" } } enum_type { name: "Kind" value { name: "UNKNOWN" number: 0 options { 66001: "KindUnknown" } } value { name: "VIEW" number: 1 options { 66001: "KindView" } } value { name: "ACTIVE" number: 2 options { 66001: "KindActive" } } value { name: "COMMITTED" number: 3 options { 66001: "KindCommitted" } } options { 62001: 0 62023: "Kind" } } service { name: "Snapshots" method { name: "Prepare" input_type: ".containerd.services.snapshots.v1.PrepareSnapshotRequest" output_type: ".containerd.services.snapshots.v1.PrepareSnapshotResponse" } method { name: "View" input_type: ".containerd.services.snapshots.v1.ViewSnapshotRequest" output_type: ".containerd.services.snapshots.v1.ViewSnapshotResponse" } method { name: "Mounts" input_type: ".containerd.services.snapshots.v1.MountsRequest" output_type: ".containerd.services.snapshots.v1.MountsResponse" } method { name: "Commit" input_type: ".containerd.services.snapshots.v1.CommitSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Remove" input_type: ".containerd.services.snapshots.v1.RemoveSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Stat" input_type: ".containerd.services.snapshots.v1.StatSnapshotRequest" output_type: ".containerd.services.snapshots.v1.StatSnapshotResponse" } method { name: "Update" input_type: ".containerd.services.snapshots.v1.UpdateSnapshotRequest" output_type: ".containerd.services.snapshots.v1.UpdateSnapshotResponse" } method { name: "List" input_type: ".containerd.services.snapshots.v1.ListSnapshotsRequest" output_type: ".containerd.services.snapshots.v1.ListSnapshotsResponse" server_streaming: true } method { name: "Usage" input_type: ".containerd.services.snapshots.v1.UsageRequest" output_type: ".containerd.services.snapshots.v1.UsageResponse" } } options { go_package: "github.com/containerd/containerd/api/services/snapshots/v1;snapshots" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/metrics.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Metric" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "timestamp" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "data" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "data" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/task/task.proto" package: "containerd.v1.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/any.proto" message_type { name: "Process" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "status" number: 4 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.v1.types.Status" json_name: "status" } field { name: "stdin" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 8 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "exit_status" number: 9 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 10 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "ProcessInfo" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "info" } } enum_type { name: "Status" value { name: "UNKNOWN" number: 0 options { 66001: "StatusUnknown" } } value { name: "CREATED" number: 1 options { 66001: "StatusCreated" } } value { name: "RUNNING" number: 2 options { 66001: "StatusRunning" } } value { name: "STOPPED" number: 3 options { 66001: "StatusStopped" } } value { name: "PAUSED" number: 4 options { 66001: "StatusPaused" } } value { name: "PAUSING" number: 5 options { 66001: "StatusPausing" } } options { 62001: 0 62023: "Status" } } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto" package: "containerd.services.tasks.v1" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/metrics.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" dependency: "github.com/containerd/containerd/api/types/task/task.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "CreateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "stdin" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 7 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "checkpoint" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "checkpoint" } field { name: "options" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CreateTaskResponse" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "StartRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "StartResponse" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "DeleteTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "DeleteResponse" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "DeleteProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetResponse" field { name: "process" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "process" } } message_type { name: "ListTasksRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListTasksResponse" field { name: "tasks" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "tasks" } } message_type { name: "KillRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "signal" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "signal" } field { name: "all" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "all" } } message_type { name: "ExecProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "stdin" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 5 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "spec" number: 6 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "exec_id" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "ExecProcessResponse" } message_type { name: "ResizePtyRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "width" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "width" } field { name: "height" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "height" } } message_type { name: "CloseIORequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "stdin" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "stdin" } } message_type { name: "PauseTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ResumeTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsResponse" field { name: "processes" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.ProcessInfo" json_name: "processes" } } message_type { name: "CheckpointTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "parent_checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "parentCheckpoint" } field { name: "options" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CheckpointTaskResponse" field { name: "descriptors" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "descriptors" } } message_type { name: "UpdateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "resources" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "resources" } } message_type { name: "MetricsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "MetricsResponse" field { name: "metrics" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Metric" json_name: "metrics" } } message_type { name: "WaitRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "WaitResponse" field { name: "exit_status" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } service { name: "Tasks" method { name: "Create" input_type: ".containerd.services.tasks.v1.CreateTaskRequest" output_type: ".containerd.services.tasks.v1.CreateTaskResponse" } method { name: "Start" input_type: ".containerd.services.tasks.v1.StartRequest" output_type: ".containerd.services.tasks.v1.StartResponse" } method { name: "Delete" input_type: ".containerd.services.tasks.v1.DeleteTaskRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "DeleteProcess" input_type: ".containerd.services.tasks.v1.DeleteProcessRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "Get" input_type: ".containerd.services.tasks.v1.GetRequest" output_type: ".containerd.services.tasks.v1.GetResponse" } method { name: "List" input_type: ".containerd.services.tasks.v1.ListTasksRequest" output_type: ".containerd.services.tasks.v1.ListTasksResponse" } method { name: "Kill" input_type: ".containerd.services.tasks.v1.KillRequest" output_type: ".google.protobuf.Empty" } method { name: "Exec" input_type: ".containerd.services.tasks.v1.ExecProcessRequest" output_type: ".google.protobuf.Empty" } method { name: "ResizePty" input_type: ".containerd.services.tasks.v1.ResizePtyRequest" output_type: ".google.protobuf.Empty" } method { name: "CloseIO" input_type: ".containerd.services.tasks.v1.CloseIORequest" output_type: ".google.protobuf.Empty" } method { name: "Pause" input_type: ".containerd.services.tasks.v1.PauseTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Resume" input_type: ".containerd.services.tasks.v1.ResumeTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "ListPids" input_type: ".containerd.services.tasks.v1.ListPidsRequest" output_type: ".containerd.services.tasks.v1.ListPidsResponse" } method { name: "Checkpoint" input_type: ".containerd.services.tasks.v1.CheckpointTaskRequest" output_type: ".containerd.services.tasks.v1.CheckpointTaskResponse" } method { name: "Update" input_type: ".containerd.services.tasks.v1.UpdateTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Metrics" input_type: ".containerd.services.tasks.v1.MetricsRequest" output_type: ".containerd.services.tasks.v1.MetricsResponse" } method { name: "Wait" input_type: ".containerd.services.tasks.v1.WaitRequest" output_type: ".containerd.services.tasks.v1.WaitResponse" } } options { go_package: "github.com/containerd/containerd/api/services/tasks/v1;tasks" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/version/v1/version.proto" package: "containerd.services.version.v1" dependency: "google/protobuf/empty.proto" dependency: "gogoproto/gogo.proto" message_type { name: "VersionResponse" field { name: "version" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "version" } field { name: "revision" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "revision" } } service { name: "Version" method { name: "Version" input_type: ".google.protobuf.Empty" output_type: ".containerd.services.version.v1.VersionResponse" } } options { go_package: "github.com/containerd/containerd/api/services/version/v1;version" } weak_dependency: 1 syntax: "proto3" } containerd-1.5.9/api/README.md000066400000000000000000000015721416535272200157200ustar00rootroot00000000000000This directory contains the GRPC API definitions for containerd. All defined services and messages have been aggregated into `*.pb.txt` descriptors files in this directory. Definitions present here are considered frozen after the release. At release time, the current `next.pb.txt` file will be moved into place to freeze the API changes for the minor version. For example, when 1.0.0 is released, `next.pb.txt` should be moved to `1.0.txt`. Notice that we leave off the patch number, since the API will be completely locked down for a given patch series. We may find that by default, protobuf descriptors are too noisy to lock down API changes. In that case, we may filter out certain fields in the descriptors, possibly regenerating for old versions. This process is similar to the [process used to ensure backwards compatibility in Go](https://github.com/golang/go/tree/master/api). containerd-1.5.9/api/events/000077500000000000000000000000001416535272200157405ustar00rootroot00000000000000containerd-1.5.9/api/events/container.pb.go000066400000000000000000001101701416535272200206510ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/container.proto package events import ( fmt "fmt" github_com_containerd_typeurl "github.com/containerd/typeurl" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ContainerCreate struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` Runtime *ContainerCreate_Runtime `protobuf:"bytes,3,opt,name=runtime,proto3" json:"runtime,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerCreate) Reset() { *m = ContainerCreate{} } func (*ContainerCreate) ProtoMessage() {} func (*ContainerCreate) Descriptor() ([]byte, []int) { return fileDescriptor_0d1f05b8626f83ea, []int{0} } func (m *ContainerCreate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerCreate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ContainerCreate) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerCreate.Merge(m, src) } func (m *ContainerCreate) XXX_Size() int { return m.Size() } func (m *ContainerCreate) XXX_DiscardUnknown() { xxx_messageInfo_ContainerCreate.DiscardUnknown(m) } var xxx_messageInfo_ContainerCreate proto.InternalMessageInfo type ContainerCreate_Runtime struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Options *types.Any `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerCreate_Runtime) Reset() { *m = ContainerCreate_Runtime{} } func (*ContainerCreate_Runtime) ProtoMessage() {} func (*ContainerCreate_Runtime) Descriptor() ([]byte, []int) { return fileDescriptor_0d1f05b8626f83ea, []int{0, 0} } func (m *ContainerCreate_Runtime) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerCreate_Runtime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerCreate_Runtime.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ContainerCreate_Runtime) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerCreate_Runtime.Merge(m, src) } func (m *ContainerCreate_Runtime) XXX_Size() int { return m.Size() } func (m *ContainerCreate_Runtime) XXX_DiscardUnknown() { xxx_messageInfo_ContainerCreate_Runtime.DiscardUnknown(m) } var xxx_messageInfo_ContainerCreate_Runtime proto.InternalMessageInfo type ContainerUpdate struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` 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"` SnapshotKey string `protobuf:"bytes,4,opt,name=snapshot_key,json=snapshotKey,proto3" json:"snapshot_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerUpdate) Reset() { *m = ContainerUpdate{} } func (*ContainerUpdate) ProtoMessage() {} func (*ContainerUpdate) Descriptor() ([]byte, []int) { return fileDescriptor_0d1f05b8626f83ea, []int{1} } func (m *ContainerUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerUpdate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ContainerUpdate) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerUpdate.Merge(m, src) } func (m *ContainerUpdate) XXX_Size() int { return m.Size() } func (m *ContainerUpdate) XXX_DiscardUnknown() { xxx_messageInfo_ContainerUpdate.DiscardUnknown(m) } var xxx_messageInfo_ContainerUpdate proto.InternalMessageInfo type ContainerDelete struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerDelete) Reset() { *m = ContainerDelete{} } func (*ContainerDelete) ProtoMessage() {} func (*ContainerDelete) Descriptor() ([]byte, []int) { return fileDescriptor_0d1f05b8626f83ea, []int{2} } func (m *ContainerDelete) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerDelete.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ContainerDelete) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerDelete.Merge(m, src) } func (m *ContainerDelete) XXX_Size() int { return m.Size() } func (m *ContainerDelete) XXX_DiscardUnknown() { xxx_messageInfo_ContainerDelete.DiscardUnknown(m) } var xxx_messageInfo_ContainerDelete proto.InternalMessageInfo func init() { proto.RegisterType((*ContainerCreate)(nil), "containerd.events.ContainerCreate") proto.RegisterType((*ContainerCreate_Runtime)(nil), "containerd.events.ContainerCreate.Runtime") proto.RegisterType((*ContainerUpdate)(nil), "containerd.events.ContainerUpdate") proto.RegisterMapType((map[string]string)(nil), "containerd.events.ContainerUpdate.LabelsEntry") proto.RegisterType((*ContainerDelete)(nil), "containerd.events.ContainerDelete") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/container.proto", fileDescriptor_0d1f05b8626f83ea) } var fileDescriptor_0d1f05b8626f83ea = []byte{ // 413 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x0a, 0xd3, 0x30, 0x18, 0xc7, 0x97, 0x76, 0x6e, 0x98, 0x0a, 0x6a, 0x18, 0x52, 0x7b, 0xa8, 0x73, 0xa7, 0xe9, 0x21, 0x85, 0x7a, 0x51, 0x77, 0xd1, 0x6d, 0x0a, 0xa2, 0x82, 0x14, 0x84, 0xe1, 0x45, 0xd2, 0x35, 0xeb, 0x82, 0x6d, 0x52, 0xda, 0x74, 0xd0, 0x9b, 0x8f, 0xe2, 0xe3, 0xec, 0xe8, 0xc1, 0x83, 0x27, 0x71, 0x05, 0xdf, 0xc0, 0x07, 0x90, 0x26, 0xeb, 0x56, 0x14, 0x95, 0x9d, 0xfa, 0xcf, 0xd7, 0xff, 0x3f, 0xdf, 0xf7, 0xfb, 0x08, 0x9c, 0xc5, 0x4c, 0x6e, 0xcb, 0x10, 0xaf, 0x45, 0xea, 0xad, 0x05, 0x97, 0x84, 0x71, 0x9a, 0x47, 0x5d, 0x49, 0x32, 0xe6, 0xd1, 0x1d, 0xe5, 0xb2, 0x38, 0x57, 0x71, 0x96, 0x0b, 0x29, 0xd0, 0xcd, 0xb3, 0x0d, 0x6b, 0x8b, 0x73, 0x3b, 0x16, 0x22, 0x4e, 0xa8, 0xa7, 0x0c, 0x61, 0xb9, 0xf1, 0x08, 0xaf, 0xb4, 0xdb, 0x19, 0xc5, 0x22, 0x16, 0x4a, 0x7a, 0x8d, 0x3a, 0x56, 0x9f, 0xfc, 0x77, 0x80, 0xd3, 0x55, 0x59, 0x52, 0xc6, 0x8c, 0x7b, 0x1b, 0x46, 0x93, 0x28, 0x23, 0x72, 0xab, 0x6f, 0x98, 0x7c, 0x01, 0xf0, 0xfa, 0xa2, 0xb5, 0x2f, 0x72, 0x4a, 0x24, 0x45, 0xb7, 0xa0, 0xc1, 0x22, 0x1b, 0x8c, 0xc1, 0xf4, 0xea, 0x7c, 0x50, 0x7f, 0xbb, 0x63, 0xbc, 0x58, 0x06, 0x06, 0x8b, 0xd0, 0x08, 0x5e, 0x61, 0x29, 0x89, 0xa9, 0x6d, 0x34, 0xbf, 0x02, 0x7d, 0x40, 0x4b, 0x38, 0xcc, 0x4b, 0x2e, 0x59, 0x4a, 0x6d, 0x73, 0x0c, 0xa6, 0x96, 0x7f, 0x1f, 0xff, 0x41, 0x86, 0x7f, 0x6b, 0x81, 0x03, 0x9d, 0x08, 0xda, 0xa8, 0xf3, 0x1a, 0x0e, 0x8f, 0x35, 0x84, 0x60, 0x9f, 0x93, 0x94, 0xea, 0x01, 0x02, 0xa5, 0x11, 0x86, 0x43, 0x91, 0x49, 0x26, 0x78, 0xa1, 0x9a, 0x5b, 0xfe, 0x08, 0xeb, 0x5d, 0xe1, 0x16, 0x10, 0x3f, 0xe5, 0x55, 0xd0, 0x9a, 0x26, 0x3f, 0xba, 0x58, 0x6f, 0xb3, 0xe8, 0x72, 0xac, 0xe7, 0x70, 0x90, 0x90, 0x90, 0x26, 0x85, 0x6d, 0x8e, 0xcd, 0xa9, 0xe5, 0xe3, 0x7f, 0x51, 0xe9, 0x0e, 0xf8, 0x95, 0x0a, 0x3c, 0xe3, 0x32, 0xaf, 0x82, 0x63, 0x1a, 0xdd, 0x85, 0xd7, 0x0a, 0x4e, 0xb2, 0x62, 0x2b, 0xe4, 0xfb, 0x0f, 0xb4, 0xb2, 0xfb, 0xaa, 0x89, 0xd5, 0xd6, 0x5e, 0xd2, 0xca, 0x79, 0x04, 0xad, 0x4e, 0x12, 0xdd, 0x80, 0x66, 0x63, 0xd4, 0xf8, 0x8d, 0x6c, 0x26, 0xdc, 0x91, 0xa4, 0x3c, 0x4d, 0xa8, 0x0e, 0x8f, 0x8d, 0x87, 0x60, 0x72, 0xaf, 0x83, 0xb9, 0xa4, 0x09, 0xfd, 0x3b, 0xe6, 0xfc, 0xcd, 0xfe, 0xe0, 0xf6, 0xbe, 0x1e, 0xdc, 0xde, 0xc7, 0xda, 0x05, 0xfb, 0xda, 0x05, 0x9f, 0x6b, 0x17, 0x7c, 0xaf, 0x5d, 0xf0, 0xe9, 0xa7, 0x0b, 0xde, 0xf9, 0x17, 0x3c, 0xe5, 0x99, 0xfe, 0xac, 0xc0, 0xca, 0x08, 0x07, 0x6a, 0xff, 0x0f, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x09, 0xe0, 0xd6, 0x0b, 0x03, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ContainerCreate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "id": return string(m.ID), len(m.ID) > 0 case "image": return string(m.Image), len(m.Image) > 0 case "runtime": // NOTE(stevvooe): This is probably not correct in many cases. // We assume that the target message also implements the Field // method, which isn't likely true in a lot of cases. // // If you have a broken build and have found this comment, // you may be closer to a solution. if m.Runtime == nil { return "", false } return m.Runtime.Field(fieldpath[1:]) } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ContainerCreate_Runtime) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 case "options": decoded, err := github_com_containerd_typeurl.UnmarshalAny(m.Options) if err != nil { return "", false } adaptor, ok := decoded.(interface{ Field([]string) (string, bool) }) if !ok { return "", false } return adaptor.Field(fieldpath[1:]) } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ContainerUpdate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "id": return string(m.ID), len(m.ID) > 0 case "image": return string(m.Image), len(m.Image) > 0 case "labels": // Labels fields have been special-cased by name. If this breaks, // add better special casing to fieldpath plugin. if len(m.Labels) == 0 { return "", false } value, ok := m.Labels[strings.Join(fieldpath[1:], ".")] return value, ok case "snapshot_key": return string(m.SnapshotKey), len(m.SnapshotKey) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ContainerDelete) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "id": return string(m.ID), len(m.ID) > 0 } return "", false } func (m *ContainerCreate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ContainerCreate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Runtime != nil { { size, err := m.Runtime.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainer(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if len(m.Image) > 0 { i -= len(m.Image) copy(dAtA[i:], m.Image) i = encodeVarintContainer(dAtA, i, uint64(len(m.Image))) i-- dAtA[i] = 0x12 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerCreate_Runtime) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ContainerCreate_Runtime) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerCreate_Runtime) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Options != nil { { size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainer(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintContainer(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerUpdate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ContainerUpdate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.SnapshotKey) > 0 { i -= len(m.SnapshotKey) copy(dAtA[i:], m.SnapshotKey) i = encodeVarintContainer(dAtA, i, uint64(len(m.SnapshotKey))) i-- dAtA[i] = 0x22 } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintContainer(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintContainer(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintContainer(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if len(m.Image) > 0 { i -= len(m.Image) copy(dAtA[i:], m.Image) i = encodeVarintContainer(dAtA, i, uint64(len(m.Image))) i-- dAtA[i] = 0x12 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerDelete) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ContainerDelete) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainer(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintContainer(dAtA []byte, offset int, v uint64) int { offset -= sovContainer(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *ContainerCreate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } l = len(m.Image) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } if m.Runtime != nil { l = m.Runtime.Size() n += 1 + l + sovContainer(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ContainerCreate_Runtime) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } if m.Options != nil { l = m.Options.Size() n += 1 + l + sovContainer(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ContainerUpdate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } l = len(m.Image) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovContainer(uint64(len(k))) + 1 + len(v) + sovContainer(uint64(len(v))) n += mapEntrySize + 1 + sovContainer(uint64(mapEntrySize)) } } l = len(m.SnapshotKey) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ContainerDelete) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainer(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovContainer(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozContainer(x uint64) (n int) { return sovContainer(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *ContainerCreate) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerCreate{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "ContainerCreate_Runtime", "ContainerCreate_Runtime", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ContainerCreate_Runtime) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerCreate_Runtime{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ContainerUpdate) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&ContainerUpdate{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Labels:` + mapStringForLabels + `,`, `SnapshotKey:` + fmt.Sprintf("%v", this.SnapshotKey) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ContainerDelete) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerDelete{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringContainer(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *ContainerCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ContainerCreate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.Image = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } if m.Runtime == nil { m.Runtime = &ContainerCreate_Runtime{} } if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainer } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ContainerCreate_Runtime) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Runtime: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } if m.Options == nil { m.Options = &types.Any{} } if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainer } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ContainerUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ContainerUpdate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.Image = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthContainer } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthContainer } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthContainer } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthContainer } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainer } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SnapshotKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.SnapshotKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainer } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ContainerDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ContainerDelete: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainer } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainer } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainer } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainer(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainer } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipContainer(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainer } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainer } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainer } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthContainer } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupContainer } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthContainer } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthContainer = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowContainer = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupContainer = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/container.proto000066400000000000000000000023141416535272200210070ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.events; import "google/protobuf/any.proto"; import weak "gogoproto/gogo.proto"; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message ContainerCreate { string id = 1; string image = 2; message Runtime { string name = 1; google.protobuf.Any options = 2; } Runtime runtime = 3; } message ContainerUpdate { string id = 1; string image = 2; map labels = 3; string snapshot_key = 4; } message ContainerDelete { string id = 1; } containerd-1.5.9/api/events/content.pb.go000066400000000000000000000227121416535272200203450ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/content.proto package events import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ContentDelete struct { Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContentDelete) Reset() { *m = ContentDelete{} } func (*ContentDelete) ProtoMessage() {} func (*ContentDelete) Descriptor() ([]byte, []int) { return fileDescriptor_dfb34b8b808e2ecd, []int{0} } func (m *ContentDelete) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContentDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContentDelete.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ContentDelete) XXX_Merge(src proto.Message) { xxx_messageInfo_ContentDelete.Merge(m, src) } func (m *ContentDelete) XXX_Size() int { return m.Size() } func (m *ContentDelete) XXX_DiscardUnknown() { xxx_messageInfo_ContentDelete.DiscardUnknown(m) } var xxx_messageInfo_ContentDelete proto.InternalMessageInfo func init() { proto.RegisterType((*ContentDelete)(nil), "containerd.events.ContentDelete") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/content.proto", fileDescriptor_dfb34b8b808e2ecd) } var fileDescriptor_dfb34b8b808e2ecd = []byte{ // 228 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0x14, 0x83, 0x45, 0x53, 0xf3, 0x4a, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x04, 0x11, 0x8a, 0xf4, 0x20, 0x0a, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, 0xa1, 0x94, 0x03, 0x41, 0x3b, 0xc0, 0xea, 0x92, 0x4a, 0xd3, 0xf4, 0x0b, 0x72, 0x4a, 0xd3, 0x33, 0xf3, 0xf4, 0xd3, 0x32, 0x53, 0x73, 0x52, 0x0a, 0x12, 0x4b, 0x32, 0x20, 0x26, 0x28, 0x45, 0x73, 0xf1, 0x3a, 0x43, 0xec, 0x76, 0x49, 0xcd, 0x49, 0x2d, 0x49, 0x15, 0xf2, 0xe2, 0x62, 0x4b, 0xc9, 0x4c, 0x4f, 0x2d, 0x2e, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x74, 0x32, 0x3a, 0x71, 0x4f, 0x9e, 0xe1, 0xd6, 0x3d, 0x79, 0x2d, 0x24, 0xab, 0xf2, 0x0b, 0x52, 0xf3, 0xe0, 0x76, 0x14, 0xeb, 0xa7, 0xe7, 0xeb, 0x42, 0xb4, 0xe8, 0xb9, 0x80, 0xa9, 0x20, 0xa8, 0x09, 0x4e, 0x01, 0x27, 0x1e, 0xca, 0x31, 0xdc, 0x78, 0x28, 0xc7, 0xd0, 0xf0, 0x48, 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x5c, 0xf0, 0x45, 0x8e, 0x31, 0xca, 0x88, 0x84, 0x00, 0xb2, 0x86, 0x50, 0x11, 0x0c, 0x11, 0x8c, 0x49, 0x6c, 0x60, 0x97, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x4b, 0x78, 0x99, 0xee, 0x61, 0x01, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ContentDelete) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "digest": return string(m.Digest), len(m.Digest) > 0 } return "", false } func (m *ContentDelete) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ContentDelete) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContentDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintContent(dAtA []byte, offset int, v uint64) int { offset -= sovContent(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *ContentDelete) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovContent(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozContent(x uint64) (n int) { return sovContent(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *ContentDelete) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContentDelete{`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringContent(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *ContentDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ContentDelete: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContentDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipContent(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthContent } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupContent } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthContent } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthContent = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowContent = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupContent = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/content.proto000066400000000000000000000017621416535272200205050ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.events; import weak "gogoproto/gogo.proto"; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message ContentDelete { string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; } containerd-1.5.9/api/events/doc.go000066400000000000000000000012731416535272200170370ustar00rootroot00000000000000/* Copyright The containerd 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 events has protobuf types for various events that are used in // containerd. package events containerd-1.5.9/api/events/image.pb.go000066400000000000000000000674421416535272200177660ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/image.proto package events import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ImageCreate struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImageCreate) Reset() { *m = ImageCreate{} } func (*ImageCreate) ProtoMessage() {} func (*ImageCreate) Descriptor() ([]byte, []int) { return fileDescriptor_7085610f7b33e042, []int{0} } func (m *ImageCreate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageCreate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ImageCreate) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageCreate.Merge(m, src) } func (m *ImageCreate) XXX_Size() int { return m.Size() } func (m *ImageCreate) XXX_DiscardUnknown() { xxx_messageInfo_ImageCreate.DiscardUnknown(m) } var xxx_messageInfo_ImageCreate proto.InternalMessageInfo type ImageUpdate struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImageUpdate) Reset() { *m = ImageUpdate{} } func (*ImageUpdate) ProtoMessage() {} func (*ImageUpdate) Descriptor() ([]byte, []int) { return fileDescriptor_7085610f7b33e042, []int{1} } func (m *ImageUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageUpdate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ImageUpdate) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageUpdate.Merge(m, src) } func (m *ImageUpdate) XXX_Size() int { return m.Size() } func (m *ImageUpdate) XXX_DiscardUnknown() { xxx_messageInfo_ImageUpdate.DiscardUnknown(m) } var xxx_messageInfo_ImageUpdate proto.InternalMessageInfo type ImageDelete struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImageDelete) Reset() { *m = ImageDelete{} } func (*ImageDelete) ProtoMessage() {} func (*ImageDelete) Descriptor() ([]byte, []int) { return fileDescriptor_7085610f7b33e042, []int{2} } func (m *ImageDelete) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageDelete.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ImageDelete) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageDelete.Merge(m, src) } func (m *ImageDelete) XXX_Size() int { return m.Size() } func (m *ImageDelete) XXX_DiscardUnknown() { xxx_messageInfo_ImageDelete.DiscardUnknown(m) } var xxx_messageInfo_ImageDelete proto.InternalMessageInfo func init() { proto.RegisterType((*ImageCreate)(nil), "containerd.services.images.v1.ImageCreate") proto.RegisterMapType((map[string]string)(nil), "containerd.services.images.v1.ImageCreate.LabelsEntry") proto.RegisterType((*ImageUpdate)(nil), "containerd.services.images.v1.ImageUpdate") proto.RegisterMapType((map[string]string)(nil), "containerd.services.images.v1.ImageUpdate.LabelsEntry") proto.RegisterType((*ImageDelete)(nil), "containerd.services.images.v1.ImageDelete") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/image.proto", fileDescriptor_7085610f7b33e042) } var fileDescriptor_7085610f7b33e042 = []byte{ // 292 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0x14, 0xeb, 0x67, 0xe6, 0x26, 0xa6, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0xc9, 0x22, 0x94, 0xe8, 0x15, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb, 0x81, 0x15, 0x14, 0xeb, 0x95, 0x19, 0x4a, 0x39, 0x10, 0x34, 0x17, 0x6c, 0x4c, 0x52, 0x69, 0x9a, 0x7e, 0x41, 0x4e, 0x69, 0x7a, 0x66, 0x9e, 0x7e, 0x5a, 0x66, 0x6a, 0x4e, 0x4a, 0x41, 0x62, 0x49, 0x06, 0xc4, 0x02, 0xa5, 0x35, 0x8c, 0x5c, 0xdc, 0x9e, 0x20, 0xf3, 0x9c, 0x8b, 0x52, 0x13, 0x4b, 0x52, 0x85, 0x84, 0xb8, 0x58, 0xf2, 0x12, 0x73, 0x53, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0xc0, 0x6c, 0x21, 0x3f, 0x2e, 0xb6, 0x9c, 0xc4, 0xa4, 0xd4, 0x9c, 0x62, 0x09, 0x26, 0x05, 0x66, 0x0d, 0x6e, 0x23, 0x33, 0x3d, 0xbc, 0xae, 0xd2, 0x43, 0x32, 0x4f, 0xcf, 0x07, 0xac, 0xd1, 0x35, 0xaf, 0xa4, 0xa8, 0x32, 0x08, 0x6a, 0x8a, 0x94, 0x25, 0x17, 0x37, 0x92, 0xb0, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x46, 0x10, 0x53, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7, 0x34, 0x55, 0x82, 0x09, 0x2c, 0x06, 0xe1, 0x58, 0x31, 0x59, 0x30, 0x22, 0x9c, 0x1b, 0x5a, 0x90, 0x42, 0x55, 0xe7, 0x42, 0xcc, 0xa3, 0xb6, 0x73, 0x15, 0xa1, 0xae, 0x75, 0x49, 0xcd, 0x49, 0xc5, 0xee, 0x5a, 0xa7, 0x80, 0x13, 0x0f, 0xe5, 0x18, 0x6e, 0x3c, 0x94, 0x63, 0x68, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x2e, 0xf8, 0x22, 0xc7, 0x18, 0x65, 0x44, 0x42, 0xc2, 0xb1, 0x86, 0x50, 0x11, 0x0c, 0x49, 0x6c, 0xe0, 0xb8, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x41, 0x80, 0x92, 0x17, 0x77, 0x02, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ImageCreate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 case "labels": // Labels fields have been special-cased by name. If this breaks, // add better special casing to fieldpath plugin. if len(m.Labels) == 0 { return "", false } value, ok := m.Labels[strings.Join(fieldpath[1:], ".")] return value, ok } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ImageUpdate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 case "labels": // Labels fields have been special-cased by name. If this breaks, // add better special casing to fieldpath plugin. if len(m.Labels) == 0 { return "", false } value, ok := m.Labels[strings.Join(fieldpath[1:], ".")] return value, ok } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *ImageDelete) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 } return "", false } func (m *ImageCreate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImageCreate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintImage(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintImage(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintImage(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImage(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ImageUpdate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImageUpdate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintImage(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintImage(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintImage(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImage(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ImageDelete) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImageDelete) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImage(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintImage(dAtA []byte, offset int, v uint64) int { offset -= sovImage(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *ImageCreate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImage(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v))) n += mapEntrySize + 1 + sovImage(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImageUpdate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImage(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovImage(uint64(len(k))) + 1 + len(v) + sovImage(uint64(len(v))) n += mapEntrySize + 1 + sovImage(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImageDelete) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImage(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovImage(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozImage(x uint64) (n int) { return sovImage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *ImageCreate) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&ImageCreate{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ImageUpdate) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&ImageUpdate{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ImageDelete) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ImageDelete{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringImage(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *ImageCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ImageCreate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImage } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImage } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImage } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImage } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthImage } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthImage } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthImage } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthImage } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipImage(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImage } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImage(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImage } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ImageUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ImageUpdate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImage } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImage } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImage } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImage } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthImage } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthImage } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthImage } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthImage } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipImage(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImage } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImage(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImage } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ImageDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ImageDelete: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImage } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImage } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImage } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImage(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImage } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipImage(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImage } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImage } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImage } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthImage } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupImage } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthImage } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthImage = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowImage = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupImage = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/image.proto000066400000000000000000000020101416535272200201000ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.images.v1; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message ImageCreate { string name = 1; map labels = 2; } message ImageUpdate { string name = 1; map labels = 2; } message ImageDelete { string name = 1; } containerd-1.5.9/api/events/namespace.pb.go000066400000000000000000000705661416535272200206410ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/namespace.proto package events import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type NamespaceCreate struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NamespaceCreate) Reset() { *m = NamespaceCreate{} } func (*NamespaceCreate) ProtoMessage() {} func (*NamespaceCreate) Descriptor() ([]byte, []int) { return fileDescriptor_6cd45d1d5adffe29, []int{0} } func (m *NamespaceCreate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NamespaceCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NamespaceCreate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *NamespaceCreate) XXX_Merge(src proto.Message) { xxx_messageInfo_NamespaceCreate.Merge(m, src) } func (m *NamespaceCreate) XXX_Size() int { return m.Size() } func (m *NamespaceCreate) XXX_DiscardUnknown() { xxx_messageInfo_NamespaceCreate.DiscardUnknown(m) } var xxx_messageInfo_NamespaceCreate proto.InternalMessageInfo type NamespaceUpdate struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NamespaceUpdate) Reset() { *m = NamespaceUpdate{} } func (*NamespaceUpdate) ProtoMessage() {} func (*NamespaceUpdate) Descriptor() ([]byte, []int) { return fileDescriptor_6cd45d1d5adffe29, []int{1} } func (m *NamespaceUpdate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NamespaceUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NamespaceUpdate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *NamespaceUpdate) XXX_Merge(src proto.Message) { xxx_messageInfo_NamespaceUpdate.Merge(m, src) } func (m *NamespaceUpdate) XXX_Size() int { return m.Size() } func (m *NamespaceUpdate) XXX_DiscardUnknown() { xxx_messageInfo_NamespaceUpdate.DiscardUnknown(m) } var xxx_messageInfo_NamespaceUpdate proto.InternalMessageInfo type NamespaceDelete struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NamespaceDelete) Reset() { *m = NamespaceDelete{} } func (*NamespaceDelete) ProtoMessage() {} func (*NamespaceDelete) Descriptor() ([]byte, []int) { return fileDescriptor_6cd45d1d5adffe29, []int{2} } func (m *NamespaceDelete) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NamespaceDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NamespaceDelete.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *NamespaceDelete) XXX_Merge(src proto.Message) { xxx_messageInfo_NamespaceDelete.Merge(m, src) } func (m *NamespaceDelete) XXX_Size() int { return m.Size() } func (m *NamespaceDelete) XXX_DiscardUnknown() { xxx_messageInfo_NamespaceDelete.DiscardUnknown(m) } var xxx_messageInfo_NamespaceDelete proto.InternalMessageInfo func init() { proto.RegisterType((*NamespaceCreate)(nil), "containerd.events.NamespaceCreate") proto.RegisterMapType((map[string]string)(nil), "containerd.events.NamespaceCreate.LabelsEntry") proto.RegisterType((*NamespaceUpdate)(nil), "containerd.events.NamespaceUpdate") proto.RegisterMapType((map[string]string)(nil), "containerd.events.NamespaceUpdate.LabelsEntry") proto.RegisterType((*NamespaceDelete)(nil), "containerd.events.NamespaceDelete") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/namespace.proto", fileDescriptor_6cd45d1d5adffe29) } var fileDescriptor_6cd45d1d5adffe29 = []byte{ // 296 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0x14, 0xeb, 0xe7, 0x25, 0xe6, 0xa6, 0x16, 0x17, 0x24, 0x26, 0xa7, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x22, 0x94, 0xe9, 0x41, 0x94, 0x48, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x65, 0xf5, 0x41, 0x2c, 0x88, 0x42, 0x29, 0x07, 0x82, 0xb6, 0x80, 0xd5, 0x25, 0x95, 0xa6, 0xe9, 0x17, 0xe4, 0x94, 0xa6, 0x67, 0xe6, 0xe9, 0xa7, 0x65, 0xa6, 0xe6, 0xa4, 0x14, 0x24, 0x96, 0x64, 0x40, 0x4c, 0x50, 0x5a, 0xc1, 0xc8, 0xc5, 0xef, 0x07, 0xb3, 0xde, 0xb9, 0x28, 0x35, 0xb1, 0x24, 0x55, 0x48, 0x88, 0x8b, 0x05, 0xe4, 0x22, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x30, 0x5b, 0xc8, 0x8d, 0x8b, 0x2d, 0x27, 0x31, 0x29, 0x35, 0xa7, 0x58, 0x82, 0x49, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x4f, 0x0f, 0xc3, 0x8d, 0x7a, 0x68, 0xe6, 0xe8, 0xf9, 0x80, 0x35, 0xb8, 0xe6, 0x95, 0x14, 0x55, 0x06, 0x41, 0x75, 0x4b, 0x59, 0x72, 0x71, 0x23, 0x09, 0x0b, 0x09, 0x70, 0x31, 0x67, 0xa7, 0x56, 0x42, 0x6d, 0x02, 0x31, 0x85, 0x44, 0xb8, 0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0x25, 0x98, 0xc0, 0x62, 0x10, 0x8e, 0x15, 0x93, 0x05, 0x23, 0xaa, 0x53, 0x43, 0x0b, 0x52, 0xa8, 0xe2, 0x54, 0x88, 0x39, 0xd4, 0x76, 0xaa, 0x2a, 0x92, 0x4b, 0x5d, 0x52, 0x73, 0x52, 0xb1, 0xbb, 0xd4, 0x29, 0xe0, 0xc4, 0x43, 0x39, 0x86, 0x1b, 0x0f, 0xe5, 0x18, 0x1a, 0x1e, 0xc9, 0x31, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x0b, 0xbe, 0xc8, 0x31, 0x46, 0x19, 0x91, 0x90, 0x84, 0xac, 0x21, 0x54, 0x04, 0x43, 0x04, 0x63, 0x12, 0x1b, 0x38, 0x66, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x50, 0x87, 0x59, 0x83, 0x02, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *NamespaceCreate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 case "labels": // Labels fields have been special-cased by name. If this breaks, // add better special casing to fieldpath plugin. if len(m.Labels) == 0 { return "", false } value, ok := m.Labels[strings.Join(fieldpath[1:], ".")] return value, ok } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *NamespaceUpdate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 case "labels": // Labels fields have been special-cased by name. If this breaks, // add better special casing to fieldpath plugin. if len(m.Labels) == 0 { return "", false } value, ok := m.Labels[strings.Join(fieldpath[1:], ".")] return value, ok } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *NamespaceDelete) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "name": return string(m.Name), len(m.Name) > 0 } return "", false } func (m *NamespaceCreate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NamespaceCreate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NamespaceCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintNamespace(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintNamespace(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintNamespace(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *NamespaceUpdate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NamespaceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintNamespace(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintNamespace(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintNamespace(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *NamespaceDelete) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NamespaceDelete) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NamespaceDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintNamespace(dAtA []byte, offset int, v uint64) int { offset -= sovNamespace(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *NamespaceCreate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *NamespaceUpdate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *NamespaceDelete) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovNamespace(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozNamespace(x uint64) (n int) { return sovNamespace(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *NamespaceCreate) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&NamespaceCreate{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *NamespaceUpdate) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&NamespaceUpdate{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *NamespaceDelete) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&NamespaceDelete{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringNamespace(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *NamespaceCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: NamespaceCreate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NamespaceCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthNamespace } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthNamespace } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *NamespaceUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: NamespaceUpdate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NamespaceUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthNamespace } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthNamespace } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *NamespaceDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: NamespaceDelete: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NamespaceDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipNamespace(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthNamespace } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupNamespace } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthNamespace } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthNamespace = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowNamespace = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupNamespace = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/namespace.proto000066400000000000000000000020561416535272200207640ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.events; import weak "gogoproto/gogo.proto"; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message NamespaceCreate { string name = 1; map labels = 2; } message NamespaceUpdate { string name = 1; map labels = 2; } message NamespaceDelete { string name = 1; } containerd-1.5.9/api/events/snapshot.pb.go000066400000000000000000000513651416535272200205400ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/snapshot.proto package events import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type SnapshotPrepare struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Parent string `protobuf:"bytes,2,opt,name=parent,proto3" json:"parent,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotPrepare) Reset() { *m = SnapshotPrepare{} } func (*SnapshotPrepare) ProtoMessage() {} func (*SnapshotPrepare) Descriptor() ([]byte, []int) { return fileDescriptor_bd6c184d3d9aa5f2, []int{0} } func (m *SnapshotPrepare) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotPrepare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotPrepare.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *SnapshotPrepare) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotPrepare.Merge(m, src) } func (m *SnapshotPrepare) XXX_Size() int { return m.Size() } func (m *SnapshotPrepare) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotPrepare.DiscardUnknown(m) } var xxx_messageInfo_SnapshotPrepare proto.InternalMessageInfo type SnapshotCommit struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotCommit) Reset() { *m = SnapshotCommit{} } func (*SnapshotCommit) ProtoMessage() {} func (*SnapshotCommit) Descriptor() ([]byte, []int) { return fileDescriptor_bd6c184d3d9aa5f2, []int{1} } func (m *SnapshotCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotCommit.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *SnapshotCommit) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotCommit.Merge(m, src) } func (m *SnapshotCommit) XXX_Size() int { return m.Size() } func (m *SnapshotCommit) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotCommit.DiscardUnknown(m) } var xxx_messageInfo_SnapshotCommit proto.InternalMessageInfo type SnapshotRemove struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotRemove) Reset() { *m = SnapshotRemove{} } func (*SnapshotRemove) ProtoMessage() {} func (*SnapshotRemove) Descriptor() ([]byte, []int) { return fileDescriptor_bd6c184d3d9aa5f2, []int{2} } func (m *SnapshotRemove) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotRemove.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *SnapshotRemove) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotRemove.Merge(m, src) } func (m *SnapshotRemove) XXX_Size() int { return m.Size() } func (m *SnapshotRemove) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotRemove.DiscardUnknown(m) } var xxx_messageInfo_SnapshotRemove proto.InternalMessageInfo func init() { proto.RegisterType((*SnapshotPrepare)(nil), "containerd.events.SnapshotPrepare") proto.RegisterType((*SnapshotCommit)(nil), "containerd.events.SnapshotCommit") proto.RegisterType((*SnapshotRemove)(nil), "containerd.events.SnapshotRemove") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/snapshot.proto", fileDescriptor_bd6c184d3d9aa5f2) } var fileDescriptor_bd6c184d3d9aa5f2 = []byte{ // 235 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0xa7, 0x96, 0xa5, 0xe6, 0x95, 0x14, 0xeb, 0x17, 0xe7, 0x25, 0x16, 0x14, 0x67, 0xe4, 0x97, 0xe8, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x22, 0x54, 0xe9, 0x41, 0x54, 0x48, 0x39, 0x10, 0x34, 0x0e, 0xac, 0x35, 0xa9, 0x34, 0x4d, 0xbf, 0x20, 0xa7, 0x34, 0x3d, 0x33, 0x4f, 0x3f, 0x2d, 0x33, 0x35, 0x27, 0xa5, 0x20, 0xb1, 0x24, 0x03, 0x62, 0xa8, 0x92, 0x35, 0x17, 0x7f, 0x30, 0xd4, 0x9a, 0x80, 0xa2, 0xd4, 0x82, 0xc4, 0xa2, 0x54, 0x21, 0x01, 0x2e, 0xe6, 0xec, 0xd4, 0x4a, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xce, 0x20, 0x10, 0x53, 0x48, 0x8c, 0x8b, 0x0d, 0x24, 0x93, 0x57, 0x22, 0xc1, 0x04, 0x16, 0x84, 0xf2, 0x94, 0xcc, 0xb8, 0xf8, 0x60, 0x9a, 0x9d, 0xf3, 0x73, 0x73, 0x33, 0x4b, 0xb0, 0xe8, 0x15, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, 0x4d, 0x85, 0xea, 0x04, 0xb3, 0x95, 0x94, 0x10, 0xfa, 0x82, 0x52, 0x73, 0xf3, 0xcb, 0xb0, 0xd8, 0xe9, 0x14, 0x70, 0xe2, 0xa1, 0x1c, 0xc3, 0x8d, 0x87, 0x72, 0x0c, 0x0d, 0x8f, 0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x05, 0x5f, 0xe4, 0x18, 0xa3, 0x8c, 0x48, 0x08, 0x47, 0x6b, 0x08, 0x15, 0xc1, 0x90, 0xc4, 0x06, 0xf6, 0xb3, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x69, 0x66, 0xa9, 0x2a, 0x86, 0x01, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *SnapshotPrepare) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "key": return string(m.Key), len(m.Key) > 0 case "parent": return string(m.Parent), len(m.Parent) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *SnapshotCommit) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "key": return string(m.Key), len(m.Key) > 0 case "name": return string(m.Name), len(m.Name) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *SnapshotRemove) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "key": return string(m.Key), len(m.Key) > 0 } return "", false } func (m *SnapshotPrepare) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotPrepare) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SnapshotPrepare) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Parent) > 0 { i -= len(m.Parent) copy(dAtA[i:], m.Parent) i = encodeVarintSnapshot(dAtA, i, uint64(len(m.Parent))) i-- dAtA[i] = 0x12 } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshot(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SnapshotCommit) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotCommit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SnapshotCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintSnapshot(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0x12 } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshot(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SnapshotRemove) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotRemove) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SnapshotRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshot(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintSnapshot(dAtA []byte, offset int, v uint64) int { offset -= sovSnapshot(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *SnapshotPrepare) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshot(uint64(l)) } l = len(m.Parent) if l > 0 { n += 1 + l + sovSnapshot(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotCommit) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshot(uint64(l)) } l = len(m.Name) if l > 0 { n += 1 + l + sovSnapshot(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotRemove) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshot(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovSnapshot(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozSnapshot(x uint64) (n int) { return sovSnapshot(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *SnapshotPrepare) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SnapshotPrepare{`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Parent:` + fmt.Sprintf("%v", this.Parent) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *SnapshotCommit) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SnapshotCommit{`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *SnapshotRemove) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SnapshotRemove{`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringSnapshot(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *SnapshotPrepare) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SnapshotPrepare: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotPrepare: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshot } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshot } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshot } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshot } if postIndex > l { return io.ErrUnexpectedEOF } m.Parent = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshot(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshot } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SnapshotCommit) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SnapshotCommit: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotCommit: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshot } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshot } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshot } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshot } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshot(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshot } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SnapshotRemove) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SnapshotRemove: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotRemove: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshot } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshot } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshot } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshot(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshot } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipSnapshot(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshot } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshot } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshot } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthSnapshot } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupSnapshot } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthSnapshot } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthSnapshot = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowSnapshot = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupSnapshot = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/snapshot.proto000066400000000000000000000017471416535272200206750ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.events; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message SnapshotPrepare { string key = 1; string parent = 2; } message SnapshotCommit { string key = 1; string name = 2; } message SnapshotRemove { string key = 1; } containerd-1.5.9/api/events/task.pb.go000066400000000000000000002373111416535272200176400ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/events/task.proto package events import ( fmt "fmt" types "github.com/containerd/containerd/api/types" proto "github.com/gogo/protobuf/proto" _ "github.com/gogo/protobuf/types" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type TaskCreate struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Bundle string `protobuf:"bytes,2,opt,name=bundle,proto3" json:"bundle,omitempty"` Rootfs []*types.Mount `protobuf:"bytes,3,rep,name=rootfs,proto3" json:"rootfs,omitempty"` IO *TaskIO `protobuf:"bytes,4,opt,name=io,proto3" json:"io,omitempty"` Checkpoint string `protobuf:"bytes,5,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"` Pid uint32 `protobuf:"varint,6,opt,name=pid,proto3" json:"pid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskCreate) Reset() { *m = TaskCreate{} } func (*TaskCreate) ProtoMessage() {} func (*TaskCreate) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{0} } func (m *TaskCreate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskCreate.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskCreate) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskCreate.Merge(m, src) } func (m *TaskCreate) XXX_Size() int { return m.Size() } func (m *TaskCreate) XXX_DiscardUnknown() { xxx_messageInfo_TaskCreate.DiscardUnknown(m) } var xxx_messageInfo_TaskCreate proto.InternalMessageInfo type TaskStart struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskStart) Reset() { *m = TaskStart{} } func (*TaskStart) ProtoMessage() {} func (*TaskStart) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{1} } func (m *TaskStart) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskStart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskStart.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskStart) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskStart.Merge(m, src) } func (m *TaskStart) XXX_Size() int { return m.Size() } func (m *TaskStart) XXX_DiscardUnknown() { xxx_messageInfo_TaskStart.DiscardUnknown(m) } var xxx_messageInfo_TaskStart proto.InternalMessageInfo type TaskDelete struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"` ExitStatus uint32 `protobuf:"varint,3,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` ExitedAt time.Time `protobuf:"bytes,4,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` // id is the specific exec. By default if omitted will be `""` thus matches // the init exec of the task matching `container_id`. ID string `protobuf:"bytes,5,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskDelete) Reset() { *m = TaskDelete{} } func (*TaskDelete) ProtoMessage() {} func (*TaskDelete) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{2} } func (m *TaskDelete) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskDelete.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskDelete) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskDelete.Merge(m, src) } func (m *TaskDelete) XXX_Size() int { return m.Size() } func (m *TaskDelete) XXX_DiscardUnknown() { xxx_messageInfo_TaskDelete.DiscardUnknown(m) } var xxx_messageInfo_TaskDelete proto.InternalMessageInfo type TaskIO struct { Stdin string `protobuf:"bytes,1,opt,name=stdin,proto3" json:"stdin,omitempty"` Stdout string `protobuf:"bytes,2,opt,name=stdout,proto3" json:"stdout,omitempty"` Stderr string `protobuf:"bytes,3,opt,name=stderr,proto3" json:"stderr,omitempty"` Terminal bool `protobuf:"varint,4,opt,name=terminal,proto3" json:"terminal,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskIO) Reset() { *m = TaskIO{} } func (*TaskIO) ProtoMessage() {} func (*TaskIO) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{3} } func (m *TaskIO) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskIO) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskIO.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskIO) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskIO.Merge(m, src) } func (m *TaskIO) XXX_Size() int { return m.Size() } func (m *TaskIO) XXX_DiscardUnknown() { xxx_messageInfo_TaskIO.DiscardUnknown(m) } var xxx_messageInfo_TaskIO proto.InternalMessageInfo type TaskExit struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"` ExitStatus uint32 `protobuf:"varint,4,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` ExitedAt time.Time `protobuf:"bytes,5,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskExit) Reset() { *m = TaskExit{} } func (*TaskExit) ProtoMessage() {} func (*TaskExit) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{4} } func (m *TaskExit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskExit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskExit.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskExit) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskExit.Merge(m, src) } func (m *TaskExit) XXX_Size() int { return m.Size() } func (m *TaskExit) XXX_DiscardUnknown() { xxx_messageInfo_TaskExit.DiscardUnknown(m) } var xxx_messageInfo_TaskExit proto.InternalMessageInfo type TaskOOM struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskOOM) Reset() { *m = TaskOOM{} } func (*TaskOOM) ProtoMessage() {} func (*TaskOOM) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{5} } func (m *TaskOOM) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskOOM) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskOOM.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskOOM) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskOOM.Merge(m, src) } func (m *TaskOOM) XXX_Size() int { return m.Size() } func (m *TaskOOM) XXX_DiscardUnknown() { xxx_messageInfo_TaskOOM.DiscardUnknown(m) } var xxx_messageInfo_TaskOOM proto.InternalMessageInfo type TaskExecAdded struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskExecAdded) Reset() { *m = TaskExecAdded{} } func (*TaskExecAdded) ProtoMessage() {} func (*TaskExecAdded) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{6} } func (m *TaskExecAdded) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskExecAdded) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskExecAdded.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskExecAdded) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskExecAdded.Merge(m, src) } func (m *TaskExecAdded) XXX_Size() int { return m.Size() } func (m *TaskExecAdded) XXX_DiscardUnknown() { xxx_messageInfo_TaskExecAdded.DiscardUnknown(m) } var xxx_messageInfo_TaskExecAdded proto.InternalMessageInfo type TaskExecStarted struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskExecStarted) Reset() { *m = TaskExecStarted{} } func (*TaskExecStarted) ProtoMessage() {} func (*TaskExecStarted) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{7} } func (m *TaskExecStarted) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskExecStarted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskExecStarted.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskExecStarted) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskExecStarted.Merge(m, src) } func (m *TaskExecStarted) XXX_Size() int { return m.Size() } func (m *TaskExecStarted) XXX_DiscardUnknown() { xxx_messageInfo_TaskExecStarted.DiscardUnknown(m) } var xxx_messageInfo_TaskExecStarted proto.InternalMessageInfo type TaskPaused struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskPaused) Reset() { *m = TaskPaused{} } func (*TaskPaused) ProtoMessage() {} func (*TaskPaused) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{8} } func (m *TaskPaused) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskPaused) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskPaused.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskPaused) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskPaused.Merge(m, src) } func (m *TaskPaused) XXX_Size() int { return m.Size() } func (m *TaskPaused) XXX_DiscardUnknown() { xxx_messageInfo_TaskPaused.DiscardUnknown(m) } var xxx_messageInfo_TaskPaused proto.InternalMessageInfo type TaskResumed struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskResumed) Reset() { *m = TaskResumed{} } func (*TaskResumed) ProtoMessage() {} func (*TaskResumed) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{9} } func (m *TaskResumed) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskResumed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskResumed.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskResumed) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskResumed.Merge(m, src) } func (m *TaskResumed) XXX_Size() int { return m.Size() } func (m *TaskResumed) XXX_DiscardUnknown() { xxx_messageInfo_TaskResumed.DiscardUnknown(m) } var xxx_messageInfo_TaskResumed proto.InternalMessageInfo type TaskCheckpointed struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Checkpoint string `protobuf:"bytes,2,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskCheckpointed) Reset() { *m = TaskCheckpointed{} } func (*TaskCheckpointed) ProtoMessage() {} func (*TaskCheckpointed) Descriptor() ([]byte, []int) { return fileDescriptor_8db0813f7adfb63c, []int{10} } func (m *TaskCheckpointed) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskCheckpointed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskCheckpointed.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *TaskCheckpointed) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskCheckpointed.Merge(m, src) } func (m *TaskCheckpointed) XXX_Size() int { return m.Size() } func (m *TaskCheckpointed) XXX_DiscardUnknown() { xxx_messageInfo_TaskCheckpointed.DiscardUnknown(m) } var xxx_messageInfo_TaskCheckpointed proto.InternalMessageInfo func init() { proto.RegisterType((*TaskCreate)(nil), "containerd.events.TaskCreate") proto.RegisterType((*TaskStart)(nil), "containerd.events.TaskStart") proto.RegisterType((*TaskDelete)(nil), "containerd.events.TaskDelete") proto.RegisterType((*TaskIO)(nil), "containerd.events.TaskIO") proto.RegisterType((*TaskExit)(nil), "containerd.events.TaskExit") proto.RegisterType((*TaskOOM)(nil), "containerd.events.TaskOOM") proto.RegisterType((*TaskExecAdded)(nil), "containerd.events.TaskExecAdded") proto.RegisterType((*TaskExecStarted)(nil), "containerd.events.TaskExecStarted") proto.RegisterType((*TaskPaused)(nil), "containerd.events.TaskPaused") proto.RegisterType((*TaskResumed)(nil), "containerd.events.TaskResumed") proto.RegisterType((*TaskCheckpointed)(nil), "containerd.events.TaskCheckpointed") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/events/task.proto", fileDescriptor_8db0813f7adfb63c) } var fileDescriptor_8db0813f7adfb63c = []byte{ // 644 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x95, 0xcd, 0x6e, 0xd3, 0x40, 0x10, 0xc7, 0x63, 0xa7, 0x75, 0xd3, 0x09, 0x55, 0x8b, 0x55, 0x95, 0x90, 0x83, 0x1d, 0x99, 0x4b, 0x4e, 0xb6, 0x08, 0x12, 0x17, 0x84, 0xd4, 0xa4, 0xe1, 0x90, 0x43, 0x95, 0xe2, 0xf6, 0x50, 0x71, 0x89, 0x36, 0xd9, 0x4d, 0xb2, 0x34, 0xf1, 0x5a, 0xf6, 0x18, 0x15, 0x89, 0x03, 0x8f, 0xc0, 0x23, 0xf0, 0x38, 0x3d, 0x20, 0xc4, 0x91, 0x53, 0xa0, 0x7e, 0x00, 0x4e, 0x3c, 0x00, 0x5a, 0xaf, 0x93, 0xb6, 0x54, 0x7c, 0x59, 0xe2, 0x94, 0x9d, 0xd9, 0xd9, 0xff, 0xec, 0xfc, 0x76, 0x3c, 0x81, 0xc7, 0x13, 0x8e, 0xd3, 0x64, 0xe8, 0x8e, 0xc4, 0xdc, 0x1b, 0x89, 0x00, 0x09, 0x0f, 0x58, 0x44, 0xaf, 0x2f, 0x49, 0xc8, 0x3d, 0xf6, 0x8a, 0x05, 0x18, 0x7b, 0x48, 0xe2, 0x33, 0x37, 0x8c, 0x04, 0x0a, 0xf3, 0xee, 0x55, 0x84, 0xab, 0x76, 0xeb, 0xbb, 0x13, 0x31, 0x11, 0xd9, 0xae, 0x27, 0x57, 0x2a, 0xb0, 0x6e, 0x4f, 0x84, 0x98, 0xcc, 0x98, 0x97, 0x59, 0xc3, 0x64, 0xec, 0x21, 0x9f, 0xb3, 0x18, 0xc9, 0x3c, 0xcc, 0x03, 0xfe, 0xee, 0x06, 0xf8, 0x3a, 0x64, 0xb1, 0x37, 0x17, 0x49, 0x80, 0xf9, 0xb9, 0xfd, 0x3f, 0x9e, 0x5b, 0xa5, 0x0c, 0x67, 0xc9, 0x84, 0x07, 0xde, 0x98, 0xb3, 0x19, 0x0d, 0x09, 0x4e, 0x95, 0x82, 0xf3, 0x4d, 0x03, 0x38, 0x21, 0xf1, 0xd9, 0x41, 0xc4, 0x08, 0x32, 0xb3, 0x05, 0x77, 0x56, 0x87, 0x07, 0x9c, 0xd6, 0xb4, 0x86, 0xd6, 0xdc, 0xec, 0x6c, 0xa7, 0x0b, 0xbb, 0x7a, 0xb0, 0xf4, 0xf7, 0xba, 0x7e, 0x75, 0x15, 0xd4, 0xa3, 0xe6, 0x1e, 0x18, 0xc3, 0x24, 0xa0, 0x33, 0x56, 0xd3, 0x65, 0xb4, 0x9f, 0x5b, 0xa6, 0x07, 0x46, 0x24, 0x04, 0x8e, 0xe3, 0x5a, 0xb9, 0x51, 0x6e, 0x56, 0x5b, 0xf7, 0xdc, 0x6b, 0xbc, 0xb2, 0x5a, 0xdc, 0x43, 0x59, 0x8b, 0x9f, 0x87, 0x99, 0x0f, 0x41, 0xe7, 0xa2, 0xb6, 0xd6, 0xd0, 0x9a, 0xd5, 0xd6, 0x7d, 0xf7, 0x16, 0x5c, 0x57, 0xde, 0xb3, 0xd7, 0xef, 0x18, 0xe9, 0xc2, 0xd6, 0x7b, 0x7d, 0x5f, 0xe7, 0xc2, 0xb4, 0x00, 0x46, 0x53, 0x36, 0x3a, 0x0b, 0x05, 0x0f, 0xb0, 0xb6, 0x9e, 0xe5, 0xbf, 0xe6, 0x31, 0x77, 0xa0, 0x1c, 0x72, 0x5a, 0x33, 0x1a, 0x5a, 0x73, 0xcb, 0x97, 0x4b, 0xe7, 0x39, 0x6c, 0x4a, 0x9d, 0x63, 0x24, 0x11, 0x16, 0x2a, 0x37, 0x97, 0xd4, 0xaf, 0x24, 0x3f, 0xe6, 0x0c, 0xbb, 0x6c, 0xc6, 0x0a, 0x32, 0xbc, 0x25, 0x6a, 0xda, 0x50, 0x65, 0xe7, 0x1c, 0x07, 0x31, 0x12, 0x4c, 0x24, 0x42, 0xb9, 0x03, 0xd2, 0x75, 0x9c, 0x79, 0xcc, 0x36, 0x6c, 0x4a, 0x8b, 0xd1, 0x01, 0xc1, 0x1c, 0x5a, 0xdd, 0x55, 0x8d, 0xe6, 0x2e, 0x5f, 0xdd, 0x3d, 0x59, 0x36, 0x5a, 0xa7, 0x72, 0xb1, 0xb0, 0x4b, 0xef, 0xbe, 0xd8, 0x9a, 0x5f, 0x51, 0xc7, 0xda, 0x68, 0xee, 0x81, 0xce, 0xa9, 0xa2, 0x96, 0x53, 0xed, 0xfa, 0x3a, 0xa7, 0xce, 0x4b, 0x30, 0x14, 0x6b, 0x73, 0x17, 0xd6, 0x63, 0xa4, 0x3c, 0x50, 0x45, 0xf8, 0xca, 0x90, 0x2f, 0x1e, 0x23, 0x15, 0x09, 0x2e, 0x5f, 0x5c, 0x59, 0xb9, 0x9f, 0x45, 0x51, 0x76, 0x5d, 0xe5, 0x67, 0x51, 0x64, 0xd6, 0xa1, 0x82, 0x2c, 0x9a, 0xf3, 0x80, 0xcc, 0xb2, 0x9b, 0x56, 0xfc, 0x95, 0xed, 0x7c, 0xd0, 0xa0, 0x22, 0x93, 0x3d, 0x3b, 0xe7, 0x58, 0xb0, 0xfd, 0xf4, 0x9c, 0xdc, 0x8d, 0x22, 0x96, 0x48, 0xcb, 0xbf, 0x44, 0xba, 0xf6, 0x7b, 0xa4, 0xeb, 0x45, 0x90, 0x3a, 0x4f, 0x61, 0x43, 0x56, 0xd3, 0xef, 0x1f, 0x16, 0x29, 0xc6, 0x99, 0xc2, 0x96, 0x82, 0xc1, 0x46, 0x6d, 0x4a, 0x19, 0x2d, 0x44, 0xe4, 0x01, 0x6c, 0xb0, 0x73, 0x36, 0x1a, 0xac, 0xb0, 0x40, 0xba, 0xb0, 0x0d, 0xa9, 0xd9, 0xeb, 0xfa, 0x86, 0xdc, 0xea, 0x51, 0xe7, 0x0d, 0x6c, 0x2f, 0x33, 0x65, 0xdf, 0xc2, 0x7f, 0xcc, 0x75, 0xfb, 0x29, 0x9c, 0x7d, 0xf5, 0xc5, 0x1c, 0x91, 0x24, 0x2e, 0x96, 0xd8, 0x69, 0x43, 0x55, 0x2a, 0xf8, 0x2c, 0x4e, 0xe6, 0x05, 0x25, 0xc6, 0xb0, 0x93, 0x8d, 0xbe, 0xd5, 0xb8, 0x28, 0xc8, 0xe0, 0xe6, 0x10, 0xd2, 0x7f, 0x1e, 0x42, 0x9d, 0xa3, 0x8b, 0x4b, 0xab, 0xf4, 0xf9, 0xd2, 0x2a, 0xbd, 0x4d, 0x2d, 0xed, 0x22, 0xb5, 0xb4, 0x4f, 0xa9, 0xa5, 0x7d, 0x4d, 0x2d, 0xed, 0xfd, 0x77, 0x4b, 0x7b, 0xd1, 0xfa, 0x87, 0x7f, 0x9f, 0x27, 0xea, 0xe7, 0xb4, 0x74, 0x5a, 0x1e, 0x1a, 0x59, 0x47, 0x3e, 0xfa, 0x11, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x58, 0x0f, 0xec, 0xbe, 0x06, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskCreate) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: rootfs // unhandled: pid case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "bundle": return string(m.Bundle), len(m.Bundle) > 0 case "io": // NOTE(stevvooe): This is probably not correct in many cases. // We assume that the target message also implements the Field // method, which isn't likely true in a lot of cases. // // If you have a broken build and have found this comment, // you may be closer to a solution. if m.IO == nil { return "", false } return m.IO.Field(fieldpath[1:]) case "checkpoint": return string(m.Checkpoint), len(m.Checkpoint) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskStart) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: pid case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskDelete) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: pid // unhandled: exit_status // unhandled: exited_at case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "id": return string(m.ID), len(m.ID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskIO) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "stdin": return string(m.Stdin), len(m.Stdin) > 0 case "stdout": return string(m.Stdout), len(m.Stdout) > 0 case "stderr": return string(m.Stderr), len(m.Stderr) > 0 case "terminal": return fmt.Sprint(m.Terminal), true } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskExit) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: pid // unhandled: exit_status // unhandled: exited_at case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "id": return string(m.ID), len(m.ID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskOOM) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskExecAdded) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "exec_id": return string(m.ExecID), len(m.ExecID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskExecStarted) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: pid case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "exec_id": return string(m.ExecID), len(m.ExecID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskPaused) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskResumed) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 } return "", false } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *TaskCheckpointed) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { case "container_id": return string(m.ContainerID), len(m.ContainerID) > 0 case "checkpoint": return string(m.Checkpoint), len(m.Checkpoint) > 0 } return "", false } func (m *TaskCreate) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskCreate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x30 } if len(m.Checkpoint) > 0 { i -= len(m.Checkpoint) copy(dAtA[i:], m.Checkpoint) i = encodeVarintTask(dAtA, i, uint64(len(m.Checkpoint))) i-- dAtA[i] = 0x2a } if m.IO != nil { { size, err := m.IO.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTask(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.Rootfs) > 0 { for iNdEx := len(m.Rootfs) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Rootfs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTask(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } } if len(m.Bundle) > 0 { i -= len(m.Bundle) copy(dAtA[i:], m.Bundle) i = encodeVarintTask(dAtA, i, uint64(len(m.Bundle))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskStart) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskStart) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskStart) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x10 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskDelete) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskDelete) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintTask(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0x2a } n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintTask(dAtA, i, uint64(n2)) i-- dAtA[i] = 0x22 if m.ExitStatus != 0 { i = encodeVarintTask(dAtA, i, uint64(m.ExitStatus)) i-- dAtA[i] = 0x18 } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x10 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskIO) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskIO) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskIO) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Terminal { i-- if m.Terminal { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if len(m.Stderr) > 0 { i -= len(m.Stderr) copy(dAtA[i:], m.Stderr) i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr))) i-- dAtA[i] = 0x1a } if len(m.Stdout) > 0 { i -= len(m.Stdout) copy(dAtA[i:], m.Stdout) i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout))) i-- dAtA[i] = 0x12 } if len(m.Stdin) > 0 { i -= len(m.Stdin) copy(dAtA[i:], m.Stdin) i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskExit) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskExit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskExit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):]) if err3 != nil { return 0, err3 } i -= n3 i = encodeVarintTask(dAtA, i, uint64(n3)) i-- dAtA[i] = 0x2a if m.ExitStatus != 0 { i = encodeVarintTask(dAtA, i, uint64(m.ExitStatus)) i-- dAtA[i] = 0x20 } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x18 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintTask(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskOOM) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskOOM) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskOOM) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskExecAdded) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskExecAdded) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskExecAdded) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTask(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskExecStarted) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskExecStarted) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskExecStarted) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x18 } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTask(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskPaused) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskPaused) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskPaused) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskResumed) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskResumed) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskResumed) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *TaskCheckpointed) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskCheckpointed) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *TaskCheckpointed) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Checkpoint) > 0 { i -= len(m.Checkpoint) copy(dAtA[i:], m.Checkpoint) i = encodeVarintTask(dAtA, i, uint64(len(m.Checkpoint))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintTask(dAtA []byte, offset int, v uint64) int { offset -= sovTask(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *TaskCreate) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Bundle) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if len(m.Rootfs) > 0 { for _, e := range m.Rootfs { l = e.Size() n += 1 + l + sovTask(uint64(l)) } } if m.IO != nil { l = m.IO.Size() n += 1 + l + sovTask(uint64(l)) } l = len(m.Checkpoint) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskStart) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskDelete) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.ExitStatus != 0 { n += 1 + sovTask(uint64(m.ExitStatus)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) n += 1 + l + sovTask(uint64(l)) l = len(m.ID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskIO) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Stdin) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Stdout) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Stderr) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Terminal { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskExit) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.ID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.ExitStatus != 0 { n += 1 + sovTask(uint64(m.ExitStatus)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) n += 1 + l + sovTask(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskOOM) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskExecAdded) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskExecStarted) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskPaused) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskResumed) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TaskCheckpointed) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Checkpoint) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTask(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozTask(x uint64) (n int) { return sovTask(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *TaskCreate) String() string { if this == nil { return "nil" } repeatedStringForRootfs := "[]*Mount{" for _, f := range this.Rootfs { repeatedStringForRootfs += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForRootfs += "}" s := strings.Join([]string{`&TaskCreate{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Bundle:` + fmt.Sprintf("%v", this.Bundle) + `,`, `Rootfs:` + repeatedStringForRootfs + `,`, `IO:` + strings.Replace(this.IO.String(), "TaskIO", "TaskIO", 1) + `,`, `Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskStart) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskStart{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskDelete) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskDelete{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, `ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskIO) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskIO{`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskExit) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskExit{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, `ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskOOM) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskOOM{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskExecAdded) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskExecAdded{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskExecStarted) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskExecStarted{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskPaused) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskPaused{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskResumed) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskResumed{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *TaskCheckpointed) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&TaskCheckpointed{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringTask(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *TaskCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskCreate: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Bundle = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Rootfs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Rootfs = append(m.Rootfs, &types.Mount{}) if err := m.Rootfs[len(m.Rootfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field IO", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } if m.IO == nil { m.IO = &TaskIO{} } if err := m.IO.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Checkpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskStart) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskStart: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskStart: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskDelete: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) } m.ExitStatus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitStatus |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskIO) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskIO: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskIO: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdin = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdout = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stderr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Terminal = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskExit) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskExit: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskExit: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) } m.ExitStatus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitStatus |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskOOM) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskOOM: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskOOM: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskExecAdded) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskExecAdded: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskExecAdded: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskExecStarted) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskExecStarted: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskExecStarted: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskPaused) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskPaused: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskPaused: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskResumed) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskResumed: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskResumed: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *TaskCheckpointed) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: TaskCheckpointed: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskCheckpointed: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Checkpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipTask(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthTask } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupTask } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthTask } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthTask = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTask = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupTask = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/events/task.proto000066400000000000000000000043501416535272200177710ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.events; import weak "gogoproto/gogo.proto"; import "google/protobuf/timestamp.proto"; import "github.com/containerd/containerd/api/types/mount.proto"; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; option go_package = "github.com/containerd/containerd/api/events;events"; option (containerd.plugin.fieldpath_all) = true; message TaskCreate { string container_id = 1; string bundle = 2; repeated containerd.types.Mount rootfs = 3; TaskIO io = 4 [(gogoproto.customname) = "IO"]; string checkpoint = 5; uint32 pid = 6; } message TaskStart { string container_id = 1; uint32 pid = 2; } message TaskDelete { string container_id = 1; uint32 pid = 2; uint32 exit_status = 3; google.protobuf.Timestamp exited_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // id is the specific exec. By default if omitted will be `""` thus matches // the init exec of the task matching `container_id`. string id = 5; } message TaskIO { string stdin = 1; string stdout = 2; string stderr = 3; bool terminal = 4; } message TaskExit { string container_id = 1; string id = 2; uint32 pid = 3; uint32 exit_status = 4; google.protobuf.Timestamp exited_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; } message TaskOOM { string container_id = 1; } message TaskExecAdded { string container_id = 1; string exec_id = 2; } message TaskExecStarted { string container_id = 1; string exec_id = 2; uint32 pid = 3; } message TaskPaused { string container_id = 1; } message TaskResumed { string container_id = 1; } message TaskCheckpointed { string container_id = 1; string checkpoint = 2; } containerd-1.5.9/api/next.pb.txt000066400000000000000000003003551416535272200165610ustar00rootroot00000000000000file { name: "google/protobuf/any.proto" package: "google.protobuf" message_type { name: "Any" field { name: "type_url" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "typeUrl" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "value" } } options { java_package: "com.google.protobuf" java_outer_classname: "AnyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/any" objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" package: "containerd.plugin" dependency: "google/protobuf/descriptor.proto" extension { name: "fieldpath_all" extendee: ".google.protobuf.FileOptions" number: 63300 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpathAll" } extension { name: "fieldpath" extendee: ".google.protobuf.MessageOptions" number: 64400 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "fieldpath" } } file { name: "github.com/containerd/containerd/api/events/container.proto" package: "containerd.events" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContainerCreate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.ContainerCreate.Runtime" json_name: "runtime" } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } } message_type { name: "ContainerUpdate" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "image" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.ContainerUpdate.LabelsEntry" json_name: "labels" } field { name: "snapshot_key" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ContainerDelete" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 1 weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/content.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ContentDelete" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/image.proto" package: "containerd.services.images.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "ImageCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.ImageUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ImageDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/namespace.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "NamespaceCreate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceCreate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceUpdate" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.events.NamespaceUpdate.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "NamespaceDelete" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/snapshot.proto" package: "containerd.events" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "SnapshotPrepare" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } } message_type { name: "SnapshotCommit" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "SnapshotRemove" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 syntax: "proto3" } file { name: "google/protobuf/timestamp.proto" package: "google.protobuf" message_type { name: "Timestamp" field { name: "seconds" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "seconds" } field { name: "nanos" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "nanos" } } options { java_package: "com.google.protobuf" java_outer_classname: "TimestampProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/timestamp" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/mount.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Mount" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "source" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "source" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "target" } field { name: "options" number: 4 label: LABEL_REPEATED type: TYPE_STRING json_name: "options" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/events/task.proto" package: "containerd.events" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" message_type { name: "TaskCreate" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "bundle" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "bundle" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "io" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.events.TaskIO" options { 65004: "IO" } json_name: "io" } field { name: "checkpoint" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } field { name: "pid" number: 6 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskStart" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskDelete" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } field { name: "id" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "TaskIO" field { name: "stdin" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } } message_type { name: "TaskExit" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "TaskOOM" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskExecAdded" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "TaskExecStarted" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "TaskPaused" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskResumed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "TaskCheckpointed" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "checkpoint" } } options { go_package: "github.com/containerd/containerd/api/events;events" 63300: 1 } weak_dependency: 0 weak_dependency: 3 syntax: "proto3" } file { name: "google/protobuf/empty.proto" package: "google.protobuf" message_type { name: "Empty" } options { java_package: "com.google.protobuf" java_outer_classname: "EmptyProto" java_multiple_files: true go_package: "github.com/golang/protobuf/ptypes/empty" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "google/protobuf/field_mask.proto" package: "google.protobuf" message_type { name: "FieldMask" field { name: "paths" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "paths" } } options { java_package: "com.google.protobuf" java_outer_classname: "FieldMaskProto" java_multiple_files: true go_package: "google.golang.org/genproto/protobuf/field_mask;field_mask" cc_enable_arenas: true objc_class_prefix: "GPB" csharp_namespace: "Google.Protobuf.WellKnownTypes" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/containers/v1/containers.proto" package: "containerd.services.containers.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Container" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.LabelsEntry" json_name: "labels" } field { name: "image" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "image" } field { name: "runtime" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.Runtime" json_name: "runtime" } field { name: "spec" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "snapshotter" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "snapshot_key" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotKey" } field { name: "created_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "extensions" number: 10 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container.ExtensionsEntry" options { 65001: 0 } json_name: "extensions" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } nested_type { name: "Runtime" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "options" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } nested_type { name: "ExtensionsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "value" } options { map_entry: true } } } message_type { name: "GetContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "GetContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "ListContainersRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContainersResponse" field { name: "containers" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "containers" } } message_type { name: "CreateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "CreateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "UpdateContainerRequest" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateContainerResponse" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" options { 65001: 0 } json_name: "container" } } message_type { name: "DeleteContainerRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "ListContainerMessage" field { name: "container" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.containers.v1.Container" json_name: "container" } } service { name: "Containers" method { name: "Get" input_type: ".containerd.services.containers.v1.GetContainerRequest" output_type: ".containerd.services.containers.v1.GetContainerResponse" } method { name: "List" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainersResponse" } method { name: "ListStream" input_type: ".containerd.services.containers.v1.ListContainersRequest" output_type: ".containerd.services.containers.v1.ListContainerMessage" server_streaming: true } method { name: "Create" input_type: ".containerd.services.containers.v1.CreateContainerRequest" output_type: ".containerd.services.containers.v1.CreateContainerResponse" } method { name: "Update" input_type: ".containerd.services.containers.v1.UpdateContainerRequest" output_type: ".containerd.services.containers.v1.UpdateContainerResponse" } method { name: "Delete" input_type: ".containerd.services.containers.v1.DeleteContainerRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/containers/v1;containers" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/content/v1/content.proto" package: "containerd.services.content.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/empty.proto" message_type { name: "Info" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "size" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "created_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "InfoRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "InfoResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateRequest" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListContentRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListContentResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "DeleteContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "ReadContentRequest" field { name: "digest" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "offset" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } } message_type { name: "ReadContentResponse" field { name: "offset" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 2 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } } message_type { name: "Status" field { name: "started_at" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "startedAt" } field { name: "updated_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "ref" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "expected" } } message_type { name: "StatusRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } message_type { name: "StatusResponse" field { name: "status" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" json_name: "status" } } message_type { name: "ListStatusesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListStatusesResponse" field { name: "statuses" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.Status" options { 65001: 0 } json_name: "statuses" } } message_type { name: "WriteContentRequest" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "ref" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "total" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "expected" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "expected" } field { name: "offset" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "data" number: 6 label: LABEL_OPTIONAL type: TYPE_BYTES json_name: "data" } field { name: "labels" number: 7 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.content.v1.WriteContentRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "WriteContentResponse" field { name: "action" number: 1 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.content.v1.WriteAction" json_name: "action" } field { name: "started_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "startedAt" } field { name: "updated_at" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "offset" number: 4 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "offset" } field { name: "total" number: 5 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "total" } field { name: "digest" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } } message_type { name: "AbortRequest" field { name: "ref" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } } enum_type { name: "WriteAction" value { name: "STAT" number: 0 options { 66001: "WriteActionStat" } } value { name: "WRITE" number: 1 options { 66001: "WriteActionWrite" } } value { name: "COMMIT" number: 2 options { 66001: "WriteActionCommit" } } options { 62001: 0 62023: "WriteAction" } } service { name: "Content" method { name: "Info" input_type: ".containerd.services.content.v1.InfoRequest" output_type: ".containerd.services.content.v1.InfoResponse" } method { name: "Update" input_type: ".containerd.services.content.v1.UpdateRequest" output_type: ".containerd.services.content.v1.UpdateResponse" } method { name: "List" input_type: ".containerd.services.content.v1.ListContentRequest" output_type: ".containerd.services.content.v1.ListContentResponse" server_streaming: true } method { name: "Delete" input_type: ".containerd.services.content.v1.DeleteContentRequest" output_type: ".google.protobuf.Empty" } method { name: "Read" input_type: ".containerd.services.content.v1.ReadContentRequest" output_type: ".containerd.services.content.v1.ReadContentResponse" server_streaming: true } method { name: "Status" input_type: ".containerd.services.content.v1.StatusRequest" output_type: ".containerd.services.content.v1.StatusResponse" } method { name: "ListStatuses" input_type: ".containerd.services.content.v1.ListStatusesRequest" output_type: ".containerd.services.content.v1.ListStatusesResponse" } method { name: "Write" input_type: ".containerd.services.content.v1.WriteContentRequest" output_type: ".containerd.services.content.v1.WriteContentResponse" client_streaming: true server_streaming: true } method { name: "Abort" input_type: ".containerd.services.content.v1.AbortRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/content/v1;content" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/descriptor.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Descriptor" field { name: "media_type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "digest" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "digest" } field { name: "size" number: 3 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "annotations" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor.AnnotationsEntry" json_name: "annotations" } nested_type { name: "AnnotationsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/diff/v1/diff.proto" package: "containerd.services.diff.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "ApplyRequest" field { name: "diff" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } field { name: "mounts" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } field { name: "payloads" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.diff.v1.ApplyRequest.PayloadsEntry" json_name: "payloads" } nested_type { name: "PayloadsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "value" } options { map_entry: true } } } message_type { name: "ApplyResponse" field { name: "applied" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "applied" } } message_type { name: "DiffRequest" field { name: "left" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "left" } field { name: "right" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "right" } field { name: "media_type" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "mediaType" } field { name: "ref" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "ref" } field { name: "labels" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.diff.v1.DiffRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "DiffResponse" field { name: "diff" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "diff" } } service { name: "Diff" method { name: "Apply" input_type: ".containerd.services.diff.v1.ApplyRequest" output_type: ".containerd.services.diff.v1.ApplyResponse" } method { name: "Diff" input_type: ".containerd.services.diff.v1.DiffRequest" output_type: ".containerd.services.diff.v1.DiffResponse" } } options { go_package: "github.com/containerd/containerd/api/services/diff/v1;diff" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/events/v1/events.proto" package: "containerd.services.events.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "PublishRequest" field { name: "topic" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } } message_type { name: "ForwardRequest" field { name: "envelope" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.events.v1.Envelope" json_name: "envelope" } } message_type { name: "SubscribeRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "Envelope" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "timestamp" } field { name: "namespace" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "namespace" } field { name: "topic" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } options { 64400: 1 } } service { name: "Events" method { name: "Publish" input_type: ".containerd.services.events.v1.PublishRequest" output_type: ".google.protobuf.Empty" } method { name: "Forward" input_type: ".containerd.services.events.v1.ForwardRequest" output_type: ".google.protobuf.Empty" } method { name: "Subscribe" input_type: ".containerd.services.events.v1.SubscribeRequest" output_type: ".containerd.services.events.v1.Envelope" server_streaming: true } } options { go_package: "github.com/containerd/containerd/api/services/events/v1;events" } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/images/v1/images.proto" package: "containerd.services.images.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" message_type { name: "Image" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image.LabelsEntry" json_name: "labels" } field { name: "target" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" options { 65001: 0 } json_name: "target" } field { name: "created_at" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" json_name: "image" } } message_type { name: "CreateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "CreateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "UpdateImageRequest" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateImageResponse" field { name: "image" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "image" } } message_type { name: "ListImagesRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListImagesResponse" field { name: "images" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.images.v1.Image" options { 65001: 0 } json_name: "images" } } message_type { name: "DeleteImageRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } service { name: "Images" method { name: "Get" input_type: ".containerd.services.images.v1.GetImageRequest" output_type: ".containerd.services.images.v1.GetImageResponse" } method { name: "List" input_type: ".containerd.services.images.v1.ListImagesRequest" output_type: ".containerd.services.images.v1.ListImagesResponse" } method { name: "Create" input_type: ".containerd.services.images.v1.CreateImageRequest" output_type: ".containerd.services.images.v1.CreateImageResponse" } method { name: "Update" input_type: ".containerd.services.images.v1.UpdateImageRequest" output_type: ".containerd.services.images.v1.UpdateImageResponse" } method { name: "Delete" input_type: ".containerd.services.images.v1.DeleteImageRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/images/v1;images" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/platform.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" message_type { name: "Platform" field { name: "os" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65004: "OS" } json_name: "os" } field { name: "architecture" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "architecture" } field { name: "variant" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "variant" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "google/rpc/status.proto" package: "google.rpc" dependency: "google/protobuf/any.proto" message_type { name: "Status" field { name: "code" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 json_name: "code" } field { name: "message" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "message" } field { name: "details" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "details" } } options { java_package: "com.google.rpc" java_outer_classname: "StatusProto" java_multiple_files: true go_package: "rpc" objc_class_prefix: "RPC" } syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/introspection/v1/introspection.proto" package: "containerd.services.introspection.v1" dependency: "github.com/containerd/containerd/api/types/platform.proto" dependency: "google/rpc/status.proto" dependency: "google/protobuf/empty.proto" dependency: "gogoproto/gogo.proto" message_type { name: "Plugin" field { name: "type" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "requires" number: 3 label: LABEL_REPEATED type: TYPE_STRING json_name: "requires" } field { name: "platforms" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Platform" options { 65001: 0 } json_name: "platforms" } field { name: "exports" number: 5 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin.ExportsEntry" json_name: "exports" } field { name: "capabilities" number: 6 label: LABEL_REPEATED type: TYPE_STRING json_name: "capabilities" } field { name: "init_err" number: 7 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.rpc.Status" json_name: "initErr" } nested_type { name: "ExportsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PluginsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "PluginsResponse" field { name: "plugins" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.introspection.v1.Plugin" options { 65001: 0 } json_name: "plugins" } } message_type { name: "ServerResponse" field { name: "uuid" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING options { 65004: "UUID" } json_name: "uuid" } } service { name: "Introspection" method { name: "Plugins" input_type: ".containerd.services.introspection.v1.PluginsRequest" output_type: ".containerd.services.introspection.v1.PluginsResponse" } method { name: "Server" input_type: ".google.protobuf.Empty" output_type: ".containerd.services.introspection.v1.ServerResponse" } } options { go_package: "github.com/containerd/containerd/api/services/introspection/v1;introspection" } weak_dependency: 3 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/leases/v1/leases.proto" package: "containerd.services.leases.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Lease" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "created_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "labels" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.CreateRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "CreateResponse" field { name: "lease" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "lease" } } message_type { name: "DeleteRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "sync" number: 2 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "sync" } } message_type { name: "ListRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListResponse" field { name: "leases" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Lease" json_name: "leases" } } message_type { name: "Resource" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "type" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "type" } } message_type { name: "AddResourceRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "resource" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Resource" options { 65001: 0 } json_name: "resource" } } message_type { name: "DeleteResourceRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "resource" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Resource" options { 65001: 0 } json_name: "resource" } } message_type { name: "ListResourcesRequest" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } } message_type { name: "ListResourcesResponse" field { name: "resources" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.leases.v1.Resource" options { 65001: 0 } json_name: "resources" } } service { name: "Leases" method { name: "Create" input_type: ".containerd.services.leases.v1.CreateRequest" output_type: ".containerd.services.leases.v1.CreateResponse" } method { name: "Delete" input_type: ".containerd.services.leases.v1.DeleteRequest" output_type: ".google.protobuf.Empty" } method { name: "List" input_type: ".containerd.services.leases.v1.ListRequest" output_type: ".containerd.services.leases.v1.ListResponse" } method { name: "AddResource" input_type: ".containerd.services.leases.v1.AddResourceRequest" output_type: ".google.protobuf.Empty" } method { name: "DeleteResource" input_type: ".containerd.services.leases.v1.DeleteResourceRequest" output_type: ".google.protobuf.Empty" } method { name: "ListResources" input_type: ".containerd.services.leases.v1.ListResourcesRequest" output_type: ".containerd.services.leases.v1.ListResourcesResponse" } } options { go_package: "github.com/containerd/containerd/api/services/leases/v1;leases" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto" package: "containerd.services.namespaces.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" message_type { name: "Namespace" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "labels" number: 2 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "GetNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } message_type { name: "GetNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "ListNamespacesRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListNamespacesResponse" field { name: "namespaces" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespaces" } } message_type { name: "CreateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "CreateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "UpdateNamespaceRequest" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } field { name: "update_mask" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateNamespaceResponse" field { name: "namespace" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.namespaces.v1.Namespace" options { 65001: 0 } json_name: "namespace" } } message_type { name: "DeleteNamespaceRequest" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } } service { name: "Namespaces" method { name: "Get" input_type: ".containerd.services.namespaces.v1.GetNamespaceRequest" output_type: ".containerd.services.namespaces.v1.GetNamespaceResponse" } method { name: "List" input_type: ".containerd.services.namespaces.v1.ListNamespacesRequest" output_type: ".containerd.services.namespaces.v1.ListNamespacesResponse" } method { name: "Create" input_type: ".containerd.services.namespaces.v1.CreateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.CreateNamespaceResponse" } method { name: "Update" input_type: ".containerd.services.namespaces.v1.UpdateNamespaceRequest" output_type: ".containerd.services.namespaces.v1.UpdateNamespaceResponse" } method { name: "Delete" input_type: ".containerd.services.namespaces.v1.DeleteNamespaceRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/namespaces/v1;namespaces" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto" package: "containerd.services.snapshots.v1" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/field_mask.proto" dependency: "google/protobuf/timestamp.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" message_type { name: "PrepareSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.PrepareSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "PrepareSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "ViewSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "parent" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.ViewSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "ViewSnapshotResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "MountsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "MountsResponse" field { name: "mounts" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "mounts" } } message_type { name: "RemoveSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "CommitSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "name" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "key" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "labels" number: 4 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.CommitSnapshotRequest.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "Info" field { name: "name" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "name" } field { name: "parent" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "parent" } field { name: "kind" number: 3 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.services.snapshots.v1.Kind" json_name: "kind" } field { name: "created_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "createdAt" } field { name: "updated_at" number: 5 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "updatedAt" } field { name: "labels" number: 6 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info.LabelsEntry" json_name: "labels" } nested_type { name: "LabelsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "StatSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UpdateSnapshotRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } field { name: "update_mask" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.FieldMask" json_name: "updateMask" } } message_type { name: "UpdateSnapshotResponse" field { name: "info" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "ListSnapshotsRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "filters" number: 2 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "ListSnapshotsResponse" field { name: "info" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.snapshots.v1.Info" options { 65001: 0 } json_name: "info" } } message_type { name: "UsageRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } field { name: "key" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } } message_type { name: "UsageResponse" field { name: "size" number: 1 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "size" } field { name: "inodes" number: 2 label: LABEL_OPTIONAL type: TYPE_INT64 json_name: "inodes" } } message_type { name: "CleanupRequest" field { name: "snapshotter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "snapshotter" } } enum_type { name: "Kind" value { name: "UNKNOWN" number: 0 options { 66001: "KindUnknown" } } value { name: "VIEW" number: 1 options { 66001: "KindView" } } value { name: "ACTIVE" number: 2 options { 66001: "KindActive" } } value { name: "COMMITTED" number: 3 options { 66001: "KindCommitted" } } options { 62001: 0 62023: "Kind" } } service { name: "Snapshots" method { name: "Prepare" input_type: ".containerd.services.snapshots.v1.PrepareSnapshotRequest" output_type: ".containerd.services.snapshots.v1.PrepareSnapshotResponse" } method { name: "View" input_type: ".containerd.services.snapshots.v1.ViewSnapshotRequest" output_type: ".containerd.services.snapshots.v1.ViewSnapshotResponse" } method { name: "Mounts" input_type: ".containerd.services.snapshots.v1.MountsRequest" output_type: ".containerd.services.snapshots.v1.MountsResponse" } method { name: "Commit" input_type: ".containerd.services.snapshots.v1.CommitSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Remove" input_type: ".containerd.services.snapshots.v1.RemoveSnapshotRequest" output_type: ".google.protobuf.Empty" } method { name: "Stat" input_type: ".containerd.services.snapshots.v1.StatSnapshotRequest" output_type: ".containerd.services.snapshots.v1.StatSnapshotResponse" } method { name: "Update" input_type: ".containerd.services.snapshots.v1.UpdateSnapshotRequest" output_type: ".containerd.services.snapshots.v1.UpdateSnapshotResponse" } method { name: "List" input_type: ".containerd.services.snapshots.v1.ListSnapshotsRequest" output_type: ".containerd.services.snapshots.v1.ListSnapshotsResponse" server_streaming: true } method { name: "Usage" input_type: ".containerd.services.snapshots.v1.UsageRequest" output_type: ".containerd.services.snapshots.v1.UsageResponse" } method { name: "Cleanup" input_type: ".containerd.services.snapshots.v1.CleanupRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/snapshots/v1;snapshots" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/metrics.proto" package: "containerd.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "Metric" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "timestamp" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "data" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "data" } } options { go_package: "github.com/containerd/containerd/api/types;types" } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/types/task/task.proto" package: "containerd.v1.types" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/timestamp.proto" dependency: "google/protobuf/any.proto" message_type { name: "Process" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "status" number: 4 label: LABEL_OPTIONAL type: TYPE_ENUM type_name: ".containerd.v1.types.Status" json_name: "status" } field { name: "stdin" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 8 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "exit_status" number: 9 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 10 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "ProcessInfo" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "info" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "info" } } enum_type { name: "Status" value { name: "UNKNOWN" number: 0 options { 66001: "StatusUnknown" } } value { name: "CREATED" number: 1 options { 66001: "StatusCreated" } } value { name: "RUNNING" number: 2 options { 66001: "StatusRunning" } } value { name: "STOPPED" number: 3 options { 66001: "StatusStopped" } } value { name: "PAUSED" number: 4 options { 66001: "StatusPaused" } } value { name: "PAUSING" number: 5 options { 66001: "StatusPausing" } } options { 62001: 0 62023: "Status" } } weak_dependency: 0 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto" package: "containerd.services.tasks.v1" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/any.proto" dependency: "gogoproto/gogo.proto" dependency: "github.com/containerd/containerd/api/types/mount.proto" dependency: "github.com/containerd/containerd/api/types/metrics.proto" dependency: "github.com/containerd/containerd/api/types/descriptor.proto" dependency: "github.com/containerd/containerd/api/types/task/task.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "CreateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "rootfs" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Mount" json_name: "rootfs" } field { name: "stdin" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 5 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 6 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 7 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "checkpoint" number: 8 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "checkpoint" } field { name: "options" number: 9 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CreateTaskResponse" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "StartRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "StartResponse" field { name: "pid" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } } message_type { name: "DeleteTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "DeleteResponse" field { name: "id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "id" } field { name: "pid" number: 2 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "pid" } field { name: "exit_status" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } message_type { name: "DeleteProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "GetResponse" field { name: "process" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "process" } } message_type { name: "ListTasksRequest" field { name: "filter" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "filter" } } message_type { name: "ListTasksResponse" field { name: "tasks" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.Process" json_name: "tasks" } } message_type { name: "KillRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "signal" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "signal" } field { name: "all" number: 4 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "all" } } message_type { name: "ExecProcessRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "stdin" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdin" } field { name: "stdout" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stdout" } field { name: "stderr" number: 4 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "stderr" } field { name: "terminal" number: 5 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "terminal" } field { name: "spec" number: 6 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "spec" } field { name: "exec_id" number: 7 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "ExecProcessResponse" } message_type { name: "ResizePtyRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "width" number: 3 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "width" } field { name: "height" number: 4 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "height" } } message_type { name: "CloseIORequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } field { name: "stdin" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL json_name: "stdin" } } message_type { name: "PauseTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ResumeTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } } message_type { name: "ListPidsResponse" field { name: "processes" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.v1.types.ProcessInfo" json_name: "processes" } } message_type { name: "CheckpointTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "parent_checkpoint" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING options { 65001: 0 65003: "github.com/opencontainers/go-digest.Digest" } json_name: "parentCheckpoint" } field { name: "options" number: 3 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "options" } } message_type { name: "CheckpointTaskResponse" field { name: "descriptors" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Descriptor" json_name: "descriptors" } } message_type { name: "UpdateTaskRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "resources" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "resources" } field { name: "annotations" number: 3 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.services.tasks.v1.UpdateTaskRequest.AnnotationsEntry" json_name: "annotations" } nested_type { name: "AnnotationsEntry" field { name: "key" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "key" } field { name: "value" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "value" } options { map_entry: true } } } message_type { name: "MetricsRequest" field { name: "filters" number: 1 label: LABEL_REPEATED type: TYPE_STRING json_name: "filters" } } message_type { name: "MetricsResponse" field { name: "metrics" number: 1 label: LABEL_REPEATED type: TYPE_MESSAGE type_name: ".containerd.types.Metric" json_name: "metrics" } } message_type { name: "WaitRequest" field { name: "container_id" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "containerId" } field { name: "exec_id" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "execId" } } message_type { name: "WaitResponse" field { name: "exit_status" number: 1 label: LABEL_OPTIONAL type: TYPE_UINT32 json_name: "exitStatus" } field { name: "exited_at" number: 2 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "exitedAt" } } service { name: "Tasks" method { name: "Create" input_type: ".containerd.services.tasks.v1.CreateTaskRequest" output_type: ".containerd.services.tasks.v1.CreateTaskResponse" } method { name: "Start" input_type: ".containerd.services.tasks.v1.StartRequest" output_type: ".containerd.services.tasks.v1.StartResponse" } method { name: "Delete" input_type: ".containerd.services.tasks.v1.DeleteTaskRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "DeleteProcess" input_type: ".containerd.services.tasks.v1.DeleteProcessRequest" output_type: ".containerd.services.tasks.v1.DeleteResponse" } method { name: "Get" input_type: ".containerd.services.tasks.v1.GetRequest" output_type: ".containerd.services.tasks.v1.GetResponse" } method { name: "List" input_type: ".containerd.services.tasks.v1.ListTasksRequest" output_type: ".containerd.services.tasks.v1.ListTasksResponse" } method { name: "Kill" input_type: ".containerd.services.tasks.v1.KillRequest" output_type: ".google.protobuf.Empty" } method { name: "Exec" input_type: ".containerd.services.tasks.v1.ExecProcessRequest" output_type: ".google.protobuf.Empty" } method { name: "ResizePty" input_type: ".containerd.services.tasks.v1.ResizePtyRequest" output_type: ".google.protobuf.Empty" } method { name: "CloseIO" input_type: ".containerd.services.tasks.v1.CloseIORequest" output_type: ".google.protobuf.Empty" } method { name: "Pause" input_type: ".containerd.services.tasks.v1.PauseTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Resume" input_type: ".containerd.services.tasks.v1.ResumeTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "ListPids" input_type: ".containerd.services.tasks.v1.ListPidsRequest" output_type: ".containerd.services.tasks.v1.ListPidsResponse" } method { name: "Checkpoint" input_type: ".containerd.services.tasks.v1.CheckpointTaskRequest" output_type: ".containerd.services.tasks.v1.CheckpointTaskResponse" } method { name: "Update" input_type: ".containerd.services.tasks.v1.UpdateTaskRequest" output_type: ".google.protobuf.Empty" } method { name: "Metrics" input_type: ".containerd.services.tasks.v1.MetricsRequest" output_type: ".containerd.services.tasks.v1.MetricsResponse" } method { name: "Wait" input_type: ".containerd.services.tasks.v1.WaitRequest" output_type: ".containerd.services.tasks.v1.WaitResponse" } } options { go_package: "github.com/containerd/containerd/api/services/tasks/v1;tasks" } weak_dependency: 2 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/ttrpc/events/v1/events.proto" package: "containerd.services.events.ttrpc.v1" dependency: "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto" dependency: "gogoproto/gogo.proto" dependency: "google/protobuf/any.proto" dependency: "google/protobuf/empty.proto" dependency: "google/protobuf/timestamp.proto" message_type { name: "ForwardRequest" field { name: "envelope" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".containerd.services.events.ttrpc.v1.Envelope" json_name: "envelope" } } message_type { name: "Envelope" field { name: "timestamp" number: 1 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Timestamp" options { 65001: 0 65010: 1 } json_name: "timestamp" } field { name: "namespace" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "namespace" } field { name: "topic" number: 3 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "topic" } field { name: "event" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE type_name: ".google.protobuf.Any" json_name: "event" } options { 64400: 1 } } service { name: "Events" method { name: "Forward" input_type: ".containerd.services.events.ttrpc.v1.ForwardRequest" output_type: ".google.protobuf.Empty" } } options { go_package: "github.com/containerd/containerd/api/services/ttrpc/events/v1;events" } weak_dependency: 0 weak_dependency: 1 syntax: "proto3" } file { name: "github.com/containerd/containerd/api/services/version/v1/version.proto" package: "containerd.services.version.v1" dependency: "google/protobuf/empty.proto" dependency: "gogoproto/gogo.proto" message_type { name: "VersionResponse" field { name: "version" number: 1 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "version" } field { name: "revision" number: 2 label: LABEL_OPTIONAL type: TYPE_STRING json_name: "revision" } } service { name: "Version" method { name: "Version" input_type: ".google.protobuf.Empty" output_type: ".containerd.services.version.v1.VersionResponse" } } options { go_package: "github.com/containerd/containerd/api/services/version/v1;version" } weak_dependency: 1 syntax: "proto3" } containerd-1.5.9/api/services/000077500000000000000000000000001416535272200162575ustar00rootroot00000000000000containerd-1.5.9/api/services/containers/000077500000000000000000000000001416535272200204245ustar00rootroot00000000000000containerd-1.5.9/api/services/containers/v1/000077500000000000000000000000001416535272200207525ustar00rootroot00000000000000containerd-1.5.9/api/services/containers/v1/containers.pb.go000066400000000000000000003011211416535272200240440ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/containers/v1/containers.proto package containers import ( context "context" fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Container struct { // ID is the user-specified identifier. // // This field may not be updated. ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Labels provides an area to include arbitrary data on containers. // // The combined size of a key/value pair cannot exceed 4096 bytes. // // Note that to add a new value to this field, read the existing set and // include the entire result in the update call. 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"` // Image contains the reference of the image used to build the // specification and snapshots for running this container. // // If this field is updated, the spec and rootfs needed to updated, as well. Image string `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"` // Runtime specifies which runtime to use for executing this container. Runtime *Container_Runtime `protobuf:"bytes,4,opt,name=runtime,proto3" json:"runtime,omitempty"` // Spec to be used when creating the container. This is runtime specific. Spec *types.Any `protobuf:"bytes,5,opt,name=spec,proto3" json:"spec,omitempty"` // Snapshotter specifies the snapshotter name used for rootfs Snapshotter string `protobuf:"bytes,6,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` // SnapshotKey specifies the snapshot key to use for the container's root // filesystem. When starting a task from this container, a caller should // look up the mounts from the snapshot service and include those on the // task create request. // // Snapshots referenced in this field will not be garbage collected. // // This field is set to empty when the rootfs is not a snapshot. // // This field may be updated. SnapshotKey string `protobuf:"bytes,7,opt,name=snapshot_key,json=snapshotKey,proto3" json:"snapshot_key,omitempty"` // CreatedAt is the time the container was first created. CreatedAt time.Time `protobuf:"bytes,8,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` // UpdatedAt is the last time the container was mutated. UpdatedAt time.Time `protobuf:"bytes,9,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` // Extensions allow clients to provide zero or more blobs that are directly // associated with the container. One may provide protobuf, json, or other // encoding formats. The primary use of this is to further decorate the // container object with fields that may be specific to a client integration. // // The key portion of this map should identify a "name" for the extension // that should be unique against other extensions. When updating extension // data, one should only update the specified extension using field paths // to select a specific map key. Extensions map[string]types.Any `protobuf:"bytes,10,rep,name=extensions,proto3" json:"extensions" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Container) Reset() { *m = Container{} } func (*Container) ProtoMessage() {} func (*Container) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{0} } func (m *Container) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Container) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Container.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Container) XXX_Merge(src proto.Message) { xxx_messageInfo_Container.Merge(m, src) } func (m *Container) XXX_Size() int { return m.Size() } func (m *Container) XXX_DiscardUnknown() { xxx_messageInfo_Container.DiscardUnknown(m) } var xxx_messageInfo_Container proto.InternalMessageInfo type Container_Runtime struct { // Name is the name of the runtime. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Options specify additional runtime initialization options. Options *types.Any `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Container_Runtime) Reset() { *m = Container_Runtime{} } func (*Container_Runtime) ProtoMessage() {} func (*Container_Runtime) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{0, 1} } func (m *Container_Runtime) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Container_Runtime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Container_Runtime.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Container_Runtime) XXX_Merge(src proto.Message) { xxx_messageInfo_Container_Runtime.Merge(m, src) } func (m *Container_Runtime) XXX_Size() int { return m.Size() } func (m *Container_Runtime) XXX_DiscardUnknown() { xxx_messageInfo_Container_Runtime.DiscardUnknown(m) } var xxx_messageInfo_Container_Runtime proto.InternalMessageInfo type GetContainerRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetContainerRequest) Reset() { *m = GetContainerRequest{} } func (*GetContainerRequest) ProtoMessage() {} func (*GetContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{1} } func (m *GetContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetContainerRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetContainerRequest.Merge(m, src) } func (m *GetContainerRequest) XXX_Size() int { return m.Size() } func (m *GetContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_GetContainerRequest proto.InternalMessageInfo type GetContainerResponse struct { Container Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetContainerResponse) Reset() { *m = GetContainerResponse{} } func (*GetContainerResponse) ProtoMessage() {} func (*GetContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{2} } func (m *GetContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetContainerResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetContainerResponse.Merge(m, src) } func (m *GetContainerResponse) XXX_Size() int { return m.Size() } func (m *GetContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_GetContainerResponse proto.InternalMessageInfo type ListContainersRequest struct { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, containers that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainersRequest) Reset() { *m = ListContainersRequest{} } func (*ListContainersRequest) ProtoMessage() {} func (*ListContainersRequest) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{3} } func (m *ListContainersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainersRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListContainersRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainersRequest.Merge(m, src) } func (m *ListContainersRequest) XXX_Size() int { return m.Size() } func (m *ListContainersRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListContainersRequest.DiscardUnknown(m) } var xxx_messageInfo_ListContainersRequest proto.InternalMessageInfo type ListContainersResponse struct { Containers []Container `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainersResponse) Reset() { *m = ListContainersResponse{} } func (*ListContainersResponse) ProtoMessage() {} func (*ListContainersResponse) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{4} } func (m *ListContainersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainersResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListContainersResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainersResponse.Merge(m, src) } func (m *ListContainersResponse) XXX_Size() int { return m.Size() } func (m *ListContainersResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListContainersResponse.DiscardUnknown(m) } var xxx_messageInfo_ListContainersResponse proto.InternalMessageInfo type CreateContainerRequest struct { Container Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateContainerRequest) Reset() { *m = CreateContainerRequest{} } func (*CreateContainerRequest) ProtoMessage() {} func (*CreateContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{5} } func (m *CreateContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateContainerRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateContainerRequest.Merge(m, src) } func (m *CreateContainerRequest) XXX_Size() int { return m.Size() } func (m *CreateContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateContainerRequest proto.InternalMessageInfo type CreateContainerResponse struct { Container Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateContainerResponse) Reset() { *m = CreateContainerResponse{} } func (*CreateContainerResponse) ProtoMessage() {} func (*CreateContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{6} } func (m *CreateContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateContainerResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateContainerResponse.Merge(m, src) } func (m *CreateContainerResponse) XXX_Size() int { return m.Size() } func (m *CreateContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateContainerResponse proto.InternalMessageInfo // UpdateContainerRequest updates the metadata on one or more container. // // The operation should follow semantics described in // https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, // unless otherwise qualified. type UpdateContainerRequest struct { // Container provides the target values, as declared by the mask, for the update. // // The ID field must be set. Container Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container"` // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. UpdateMask *types.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateContainerRequest) Reset() { *m = UpdateContainerRequest{} } func (*UpdateContainerRequest) ProtoMessage() {} func (*UpdateContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{7} } func (m *UpdateContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateContainerRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateContainerRequest.Merge(m, src) } func (m *UpdateContainerRequest) XXX_Size() int { return m.Size() } func (m *UpdateContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateContainerRequest proto.InternalMessageInfo type UpdateContainerResponse struct { Container Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateContainerResponse) Reset() { *m = UpdateContainerResponse{} } func (*UpdateContainerResponse) ProtoMessage() {} func (*UpdateContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{8} } func (m *UpdateContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateContainerResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateContainerResponse.Merge(m, src) } func (m *UpdateContainerResponse) XXX_Size() int { return m.Size() } func (m *UpdateContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateContainerResponse proto.InternalMessageInfo type DeleteContainerRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteContainerRequest) Reset() { *m = DeleteContainerRequest{} } func (*DeleteContainerRequest) ProtoMessage() {} func (*DeleteContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{9} } func (m *DeleteContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteContainerRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteContainerRequest.Merge(m, src) } func (m *DeleteContainerRequest) XXX_Size() int { return m.Size() } func (m *DeleteContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteContainerRequest proto.InternalMessageInfo type ListContainerMessage struct { Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainerMessage) Reset() { *m = ListContainerMessage{} } func (*ListContainerMessage) ProtoMessage() {} func (*ListContainerMessage) Descriptor() ([]byte, []int) { return fileDescriptor_311afb8e15951042, []int{10} } func (m *ListContainerMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainerMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainerMessage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListContainerMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainerMessage.Merge(m, src) } func (m *ListContainerMessage) XXX_Size() int { return m.Size() } func (m *ListContainerMessage) XXX_DiscardUnknown() { xxx_messageInfo_ListContainerMessage.DiscardUnknown(m) } var xxx_messageInfo_ListContainerMessage proto.InternalMessageInfo func init() { proto.RegisterType((*Container)(nil), "containerd.services.containers.v1.Container") proto.RegisterMapType((map[string]types.Any)(nil), "containerd.services.containers.v1.Container.ExtensionsEntry") proto.RegisterMapType((map[string]string)(nil), "containerd.services.containers.v1.Container.LabelsEntry") proto.RegisterType((*Container_Runtime)(nil), "containerd.services.containers.v1.Container.Runtime") proto.RegisterType((*GetContainerRequest)(nil), "containerd.services.containers.v1.GetContainerRequest") proto.RegisterType((*GetContainerResponse)(nil), "containerd.services.containers.v1.GetContainerResponse") proto.RegisterType((*ListContainersRequest)(nil), "containerd.services.containers.v1.ListContainersRequest") proto.RegisterType((*ListContainersResponse)(nil), "containerd.services.containers.v1.ListContainersResponse") proto.RegisterType((*CreateContainerRequest)(nil), "containerd.services.containers.v1.CreateContainerRequest") proto.RegisterType((*CreateContainerResponse)(nil), "containerd.services.containers.v1.CreateContainerResponse") proto.RegisterType((*UpdateContainerRequest)(nil), "containerd.services.containers.v1.UpdateContainerRequest") proto.RegisterType((*UpdateContainerResponse)(nil), "containerd.services.containers.v1.UpdateContainerResponse") proto.RegisterType((*DeleteContainerRequest)(nil), "containerd.services.containers.v1.DeleteContainerRequest") proto.RegisterType((*ListContainerMessage)(nil), "containerd.services.containers.v1.ListContainerMessage") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/containers/v1/containers.proto", fileDescriptor_311afb8e15951042) } var fileDescriptor_311afb8e15951042 = []byte{ // 820 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcb, 0x6e, 0x13, 0x49, 0x14, 0x75, 0xdb, 0x4e, 0x3b, 0xbe, 0x1e, 0x69, 0x46, 0x35, 0x1e, 0x4f, 0x4f, 0x8f, 0x64, 0x3b, 0x5e, 0x59, 0xa3, 0xa1, 0x9d, 0x18, 0x44, 0x5e, 0x6c, 0xe2, 0xbc, 0x04, 0x24, 0x28, 0xea, 0x80, 0x84, 0x60, 0x11, 0xda, 0x76, 0xc5, 0x69, 0xdc, 0x2f, 0xba, 0xca, 0x16, 0x16, 0x8b, 0xc0, 0x1f, 0xb0, 0xe3, 0x13, 0xf8, 0x95, 0x2c, 0x59, 0xb2, 0x0a, 0xc4, 0xe2, 0x43, 0x50, 0x57, 0x57, 0xbb, 0x3b, 0x7e, 0x80, 0x9d, 0x90, 0x5d, 0x5d, 0xd7, 0x3d, 0xf7, 0x9e, 0x3a, 0xb7, 0x4e, 0xb9, 0x61, 0xaf, 0xa5, 0xd3, 0x93, 0x4e, 0x5d, 0x69, 0xd8, 0x66, 0xa5, 0x61, 0x5b, 0x54, 0xd3, 0x2d, 0xec, 0x36, 0xa3, 0x4b, 0xcd, 0xd1, 0x2b, 0x04, 0xbb, 0x5d, 0xbd, 0x81, 0x49, 0xf8, 0x3b, 0xa9, 0x74, 0x97, 0x22, 0x91, 0xe2, 0xb8, 0x36, 0xb5, 0xd1, 0x42, 0x88, 0x53, 0x02, 0x8c, 0x12, 0xc9, 0xea, 0x2e, 0xc9, 0xd9, 0x96, 0xdd, 0xb2, 0x59, 0x76, 0xc5, 0x5b, 0xf9, 0x40, 0xf9, 0x9f, 0x96, 0x6d, 0xb7, 0x0c, 0x5c, 0x61, 0x51, 0xbd, 0x73, 0x5c, 0xd1, 0xac, 0x1e, 0xdf, 0xfa, 0x77, 0x78, 0x0b, 0x9b, 0x0e, 0x0d, 0x36, 0x8b, 0xc3, 0x9b, 0xc7, 0x3a, 0x36, 0x9a, 0x47, 0xa6, 0x46, 0xda, 0x3c, 0xa3, 0x30, 0x9c, 0x41, 0x75, 0x13, 0x13, 0xaa, 0x99, 0x8e, 0x9f, 0x50, 0xfa, 0x20, 0x42, 0x7a, 0x33, 0xa0, 0x88, 0x72, 0x10, 0xd7, 0x9b, 0x92, 0x50, 0x14, 0xca, 0xe9, 0x9a, 0xd8, 0x3f, 0x2f, 0xc4, 0xef, 0x6f, 0xa9, 0x71, 0xbd, 0x89, 0x0e, 0x40, 0x34, 0xb4, 0x3a, 0x36, 0x88, 0x14, 0x2f, 0x26, 0xca, 0x99, 0xea, 0x8a, 0xf2, 0xd3, 0xa3, 0x2a, 0x83, 0xaa, 0xca, 0x1e, 0x83, 0x6e, 0x5b, 0xd4, 0xed, 0xa9, 0xbc, 0x0e, 0xca, 0xc2, 0x9c, 0x6e, 0x6a, 0x2d, 0x2c, 0x25, 0xbc, 0x66, 0xaa, 0x1f, 0xa0, 0x47, 0x90, 0x72, 0x3b, 0x96, 0xc7, 0x51, 0x4a, 0x16, 0x85, 0x72, 0xa6, 0x7a, 0x67, 0xa6, 0x46, 0xaa, 0x8f, 0x55, 0x83, 0x22, 0xa8, 0x0c, 0x49, 0xe2, 0xe0, 0x86, 0x34, 0xc7, 0x8a, 0x65, 0x15, 0x5f, 0x0d, 0x25, 0x50, 0x43, 0xd9, 0xb0, 0x7a, 0x2a, 0xcb, 0x40, 0x45, 0xc8, 0x10, 0x4b, 0x73, 0xc8, 0x89, 0x4d, 0x29, 0x76, 0x25, 0x91, 0xb1, 0x8a, 0xfe, 0x84, 0x16, 0xe0, 0xb7, 0x20, 0x3c, 0x6a, 0xe3, 0x9e, 0x94, 0xba, 0x9c, 0xf2, 0x10, 0xf7, 0xd0, 0x26, 0x40, 0xc3, 0xc5, 0x1a, 0xc5, 0xcd, 0x23, 0x8d, 0x4a, 0xf3, 0xac, 0xa9, 0x3c, 0xd2, 0xf4, 0x71, 0x30, 0x82, 0xda, 0xfc, 0xd9, 0x79, 0x21, 0xf6, 0xfe, 0x4b, 0x41, 0x50, 0xd3, 0x1c, 0xb7, 0x41, 0xbd, 0x22, 0x1d, 0xa7, 0x19, 0x14, 0x49, 0xcf, 0x52, 0x84, 0xe3, 0x36, 0x28, 0xaa, 0x03, 0xe0, 0xd7, 0x14, 0x5b, 0x44, 0xb7, 0x2d, 0x22, 0x01, 0x1b, 0xda, 0xbd, 0x99, 0xb4, 0xdc, 0x1e, 0xc0, 0xd9, 0xe0, 0x6a, 0x49, 0xaf, 0x8d, 0x1a, 0xa9, 0x2a, 0xaf, 0x42, 0x26, 0x32, 0x59, 0xf4, 0x07, 0x24, 0x3c, 0x59, 0xd8, 0xe5, 0x51, 0xbd, 0xa5, 0x37, 0xe3, 0xae, 0x66, 0x74, 0xb0, 0x14, 0xf7, 0x67, 0xcc, 0x82, 0xb5, 0xf8, 0x8a, 0x20, 0xef, 0x43, 0x8a, 0xcf, 0x0a, 0x21, 0x48, 0x5a, 0x9a, 0x89, 0x39, 0x8e, 0xad, 0x91, 0x02, 0x29, 0xdb, 0xa1, 0x8c, 0x7a, 0xfc, 0x07, 0x93, 0x0b, 0x92, 0xe4, 0x43, 0xf8, 0x7d, 0x88, 0xee, 0x18, 0x36, 0xff, 0x45, 0xd9, 0x4c, 0x2a, 0x19, 0x72, 0x2c, 0xdd, 0x82, 0x3f, 0x77, 0x31, 0x1d, 0x08, 0xa2, 0xe2, 0x57, 0x1d, 0x4c, 0xe8, 0x24, 0x8b, 0x94, 0x4e, 0x20, 0x7b, 0x39, 0x9d, 0x38, 0xb6, 0x45, 0x30, 0x3a, 0x80, 0xf4, 0x40, 0x62, 0x06, 0xcb, 0x54, 0xff, 0x9f, 0x65, 0x10, 0x5c, 0xf8, 0xb0, 0x48, 0x69, 0x09, 0xfe, 0xda, 0xd3, 0x49, 0xd8, 0x8a, 0x04, 0xd4, 0x24, 0x48, 0x1d, 0xeb, 0x06, 0xc5, 0x2e, 0x91, 0x84, 0x62, 0xa2, 0x9c, 0x56, 0x83, 0xb0, 0x64, 0x40, 0x6e, 0x18, 0xc2, 0xe9, 0xa9, 0x00, 0x61, 0x63, 0x06, 0xbb, 0x1a, 0xbf, 0x48, 0x95, 0xd2, 0x4b, 0xc8, 0x6d, 0xb2, 0xeb, 0x3c, 0x22, 0xde, 0xaf, 0x17, 0xa3, 0x0d, 0x7f, 0x8f, 0xf4, 0xba, 0x31, 0xe5, 0x3f, 0x0a, 0x90, 0x7b, 0xc2, 0x3c, 0x76, 0xf3, 0x27, 0x43, 0xeb, 0x90, 0xf1, 0xfd, 0xcc, 0xde, 0x73, 0x7e, 0x6b, 0x47, 0x1f, 0x82, 0x1d, 0xef, 0xc9, 0xdf, 0xd7, 0x48, 0x5b, 0xe5, 0xcf, 0x86, 0xb7, 0xf6, 0x64, 0x19, 0x21, 0x7a, 0x63, 0xb2, 0x2c, 0x42, 0x6e, 0x0b, 0x1b, 0x78, 0x8c, 0x2a, 0x93, 0xcc, 0x52, 0x87, 0xec, 0xa5, 0xfb, 0xb8, 0x8f, 0x09, 0xf1, 0xde, 0xff, 0x07, 0xd7, 0xe4, 0x16, 0x61, 0x55, 0xfd, 0x36, 0x07, 0x10, 0x5e, 0x78, 0xd4, 0x85, 0xc4, 0x2e, 0xa6, 0xe8, 0xee, 0x14, 0xe5, 0xc6, 0xd8, 0x5e, 0x5e, 0x9e, 0x19, 0xc7, 0xe5, 0x7e, 0x03, 0x49, 0xef, 0xa8, 0x68, 0x9a, 0xbf, 0xcc, 0xb1, 0xb6, 0x96, 0x57, 0xaf, 0x80, 0xe4, 0xcd, 0xdf, 0x09, 0x00, 0xde, 0xd6, 0x21, 0x75, 0xb1, 0x66, 0x5e, 0x83, 0xc3, 0xf2, 0xac, 0x48, 0x3e, 0xd1, 0x45, 0x01, 0x9d, 0x82, 0xe8, 0x3b, 0x14, 0x4d, 0x73, 0x90, 0xf1, 0x0f, 0x87, 0xbc, 0x76, 0x15, 0x28, 0x17, 0xe1, 0x14, 0x44, 0xdf, 0x0b, 0x53, 0x11, 0x18, 0xef, 0xef, 0xa9, 0x08, 0x4c, 0x72, 0xdc, 0x73, 0x10, 0x7d, 0x7f, 0x4c, 0x45, 0x60, 0xbc, 0x95, 0xe4, 0xdc, 0x88, 0xf3, 0xb7, 0xbd, 0x2f, 0xc1, 0xda, 0x8b, 0xb3, 0x8b, 0x7c, 0xec, 0xf3, 0x45, 0x3e, 0xf6, 0xb6, 0x9f, 0x17, 0xce, 0xfa, 0x79, 0xe1, 0x53, 0x3f, 0x2f, 0x7c, 0xed, 0xe7, 0x85, 0x67, 0x3b, 0xd7, 0xf8, 0xb8, 0x5d, 0x0f, 0xa3, 0xa7, 0xb1, 0xba, 0xc8, 0x7a, 0xde, 0xfe, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xae, 0xca, 0xcb, 0x2f, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // ContainersClient is the client API for Containers service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ContainersClient interface { Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) List(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) ListStream(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (Containers_ListStreamClient, error) Create(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) Update(ctx context.Context, in *UpdateContainerRequest, opts ...grpc.CallOption) (*UpdateContainerResponse, error) Delete(ctx context.Context, in *DeleteContainerRequest, opts ...grpc.CallOption) (*types.Empty, error) } type containersClient struct { cc *grpc.ClientConn } func NewContainersClient(cc *grpc.ClientConn) ContainersClient { return &containersClient{cc} } func (c *containersClient) Get(ctx context.Context, in *GetContainerRequest, opts ...grpc.CallOption) (*GetContainerResponse, error) { out := new(GetContainerResponse) err := c.cc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *containersClient) List(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) { out := new(ListContainersResponse) err := c.cc.Invoke(ctx, "/containerd.services.containers.v1.Containers/List", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *containersClient) ListStream(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (Containers_ListStreamClient, error) { stream, err := c.cc.NewStream(ctx, &_Containers_serviceDesc.Streams[0], "/containerd.services.containers.v1.Containers/ListStream", opts...) if err != nil { return nil, err } x := &containersListStreamClient{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 Containers_ListStreamClient interface { Recv() (*ListContainerMessage, error) grpc.ClientStream } type containersListStreamClient struct { grpc.ClientStream } func (x *containersListStreamClient) Recv() (*ListContainerMessage, error) { m := new(ListContainerMessage) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *containersClient) Create(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) { out := new(CreateContainerResponse) err := c.cc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *containersClient) Update(ctx context.Context, in *UpdateContainerRequest, opts ...grpc.CallOption) (*UpdateContainerResponse, error) { out := new(UpdateContainerResponse) err := c.cc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *containersClient) Delete(ctx context.Context, in *DeleteContainerRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.containers.v1.Containers/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } // ContainersServer is the server API for Containers service. type ContainersServer interface { Get(context.Context, *GetContainerRequest) (*GetContainerResponse, error) List(context.Context, *ListContainersRequest) (*ListContainersResponse, error) ListStream(*ListContainersRequest, Containers_ListStreamServer) error Create(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error) Update(context.Context, *UpdateContainerRequest) (*UpdateContainerResponse, error) Delete(context.Context, *DeleteContainerRequest) (*types.Empty, error) } // UnimplementedContainersServer can be embedded to have forward compatible implementations. type UnimplementedContainersServer struct { } func (*UnimplementedContainersServer) Get(ctx context.Context, req *GetContainerRequest) (*GetContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") } func (*UnimplementedContainersServer) List(ctx context.Context, req *ListContainersRequest) (*ListContainersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedContainersServer) ListStream(req *ListContainersRequest, srv Containers_ListStreamServer) error { return status.Errorf(codes.Unimplemented, "method ListStream not implemented") } func (*UnimplementedContainersServer) Create(ctx context.Context, req *CreateContainerRequest) (*CreateContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") } func (*UnimplementedContainersServer) Update(ctx context.Context, req *UpdateContainerRequest) (*UpdateContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedContainersServer) Delete(ctx context.Context, req *DeleteContainerRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func RegisterContainersServer(s *grpc.Server, srv ContainersServer) { s.RegisterService(&_Containers_serviceDesc, srv) } func _Containers_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContainersServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.containers.v1.Containers/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContainersServer).Get(ctx, req.(*GetContainerRequest)) } return interceptor(ctx, in, info, handler) } func _Containers_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListContainersRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContainersServer).List(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.containers.v1.Containers/List", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContainersServer).List(ctx, req.(*ListContainersRequest)) } return interceptor(ctx, in, info, handler) } func _Containers_ListStream_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ListContainersRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(ContainersServer).ListStream(m, &containersListStreamServer{stream}) } type Containers_ListStreamServer interface { Send(*ListContainerMessage) error grpc.ServerStream } type containersListStreamServer struct { grpc.ServerStream } func (x *containersListStreamServer) Send(m *ListContainerMessage) error { return x.ServerStream.SendMsg(m) } func _Containers_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContainersServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.containers.v1.Containers/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContainersServer).Create(ctx, req.(*CreateContainerRequest)) } return interceptor(ctx, in, info, handler) } func _Containers_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContainersServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.containers.v1.Containers/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContainersServer).Update(ctx, req.(*UpdateContainerRequest)) } return interceptor(ctx, in, info, handler) } func _Containers_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContainersServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.containers.v1.Containers/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContainersServer).Delete(ctx, req.(*DeleteContainerRequest)) } return interceptor(ctx, in, info, handler) } var _Containers_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.containers.v1.Containers", HandlerType: (*ContainersServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Get", Handler: _Containers_Get_Handler, }, { MethodName: "List", Handler: _Containers_List_Handler, }, { MethodName: "Create", Handler: _Containers_Create_Handler, }, { MethodName: "Update", Handler: _Containers_Update_Handler, }, { MethodName: "Delete", Handler: _Containers_Delete_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "ListStream", Handler: _Containers_ListStream_Handler, ServerStreams: true, }, }, Metadata: "github.com/containerd/containerd/api/services/containers/v1/containers.proto", } func (m *Container) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Container) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Extensions) > 0 { for k := range m.Extensions { v := m.Extensions[k] baseI := i { size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintContainers(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintContainers(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x52 } } n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintContainers(dAtA, i, uint64(n2)) i-- dAtA[i] = 0x4a n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) if err3 != nil { return 0, err3 } i -= n3 i = encodeVarintContainers(dAtA, i, uint64(n3)) i-- dAtA[i] = 0x42 if len(m.SnapshotKey) > 0 { i -= len(m.SnapshotKey) copy(dAtA[i:], m.SnapshotKey) i = encodeVarintContainers(dAtA, i, uint64(len(m.SnapshotKey))) i-- dAtA[i] = 0x3a } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintContainers(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0x32 } if m.Spec != nil { { size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.Runtime != nil { { size, err := m.Runtime.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.Image) > 0 { i -= len(m.Image) copy(dAtA[i:], m.Image) i = encodeVarintContainers(dAtA, i, uint64(len(m.Image))) i-- dAtA[i] = 0x1a } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintContainers(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintContainers(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintContainers(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainers(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Container_Runtime) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Container_Runtime) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Container_Runtime) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Options != nil { { size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintContainers(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetContainerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainers(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetContainerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *ListContainersRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListContainersRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintContainers(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ListContainersResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListContainersResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Containers) > 0 { for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Containers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *CreateContainerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *CreateContainerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateContainerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.UpdateMask != nil { { size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateContainerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *DeleteContainerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintContainers(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListContainerMessage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListContainerMessage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainerMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Container != nil { { size, err := m.Container.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContainers(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintContainers(dAtA []byte, offset int, v uint64) int { offset -= sovContainers(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Container) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + len(v) + sovContainers(uint64(len(v))) n += mapEntrySize + 1 + sovContainers(uint64(mapEntrySize)) } } l = len(m.Image) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } if m.Runtime != nil { l = m.Runtime.Size() n += 1 + l + sovContainers(uint64(l)) } if m.Spec != nil { l = m.Spec.Size() n += 1 + l + sovContainers(uint64(l)) } l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } l = len(m.SnapshotKey) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) n += 1 + l + sovContainers(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovContainers(uint64(l)) if len(m.Extensions) > 0 { for k, v := range m.Extensions { _ = k _ = v l = v.Size() mapEntrySize := 1 + len(k) + sovContainers(uint64(len(k))) + 1 + l + sovContainers(uint64(l)) n += mapEntrySize + 1 + sovContainers(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Container_Runtime) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } if m.Options != nil { l = m.Options.Size() n += 1 + l + sovContainers(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListContainersRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovContainers(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListContainersResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Containers) > 0 { for _, e := range m.Containers { l = e.Size() n += 1 + l + sovContainers(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) if m.UpdateMask != nil { l = m.UpdateMask.Size() n += 1 + l + sovContainers(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovContainers(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListContainerMessage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Container != nil { l = m.Container.Size() n += 1 + l + sovContainers(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovContainers(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozContainers(x uint64) (n int) { return sovContainers(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Container) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForExtensions := make([]string, 0, len(this.Extensions)) for k, _ := range this.Extensions { keysForExtensions = append(keysForExtensions, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForExtensions) mapStringForExtensions := "map[string]types.Any{" for _, k := range keysForExtensions { mapStringForExtensions += fmt.Sprintf("%v: %v,", k, this.Extensions[k]) } mapStringForExtensions += "}" s := strings.Join([]string{`&Container{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Labels:` + mapStringForLabels + `,`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Runtime:` + strings.Replace(fmt.Sprintf("%v", this.Runtime), "Container_Runtime", "Container_Runtime", 1) + `,`, `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types.Any", 1) + `,`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `SnapshotKey:` + fmt.Sprintf("%v", this.SnapshotKey) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Extensions:` + mapStringForExtensions + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Container_Runtime) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Container_Runtime{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetContainerRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetContainerResponse{`, `Container:` + strings.Replace(strings.Replace(this.Container.String(), "Container", "Container", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListContainersRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListContainersRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListContainersResponse) String() string { if this == nil { return "nil" } repeatedStringForContainers := "[]Container{" for _, f := range this.Containers { repeatedStringForContainers += strings.Replace(strings.Replace(f.String(), "Container", "Container", 1), `&`, ``, 1) + "," } repeatedStringForContainers += "}" s := strings.Join([]string{`&ListContainersResponse{`, `Containers:` + repeatedStringForContainers + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateContainerRequest{`, `Container:` + strings.Replace(strings.Replace(this.Container.String(), "Container", "Container", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateContainerResponse{`, `Container:` + strings.Replace(strings.Replace(this.Container.String(), "Container", "Container", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateContainerRequest{`, `Container:` + strings.Replace(strings.Replace(this.Container.String(), "Container", "Container", 1), `&`, ``, 1) + `,`, `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types.FieldMask", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateContainerResponse{`, `Container:` + strings.Replace(strings.Replace(this.Container.String(), "Container", "Container", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteContainerRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListContainerMessage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListContainerMessage{`, `Container:` + strings.Replace(this.Container.String(), "Container", "Container", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringContainers(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Container) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Container: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Container: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthContainers } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthContainers } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthContainers } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthContainers } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.Image = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Runtime == nil { m.Runtime = &Container_Runtime{} } if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Spec == nil { m.Spec = &types.Any{} } if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SnapshotKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.SnapshotKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Extensions == nil { m.Extensions = make(map[string]types.Any) } var mapkey string mapvalue := &types.Any{} for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthContainers } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthContainers } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return ErrInvalidLengthContainers } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return ErrInvalidLengthContainers } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &types.Any{} if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Extensions[mapkey] = *mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Container_Runtime) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Runtime: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Options == nil { m.Options = &types.Any{} } if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetContainerRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetContainerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListContainersRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListContainersRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainersRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListContainersResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListContainersResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Containers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.Containers = append(m.Containers, Container{}) if err := m.Containers[len(m.Containers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateContainerRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateContainerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateContainerRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.UpdateMask == nil { m.UpdateMask = &types.FieldMask{} } if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateContainerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteContainerRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListContainerMessage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListContainerMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainerMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContainers } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContainers } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContainers } if postIndex > l { return io.ErrUnexpectedEOF } if m.Container == nil { m.Container = &Container{} } if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContainers(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContainers } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipContainers(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainers } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainers } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContainers } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthContainers } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupContainers } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthContainers } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthContainers = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowContainers = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupContainers = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/containers/v1/containers.proto000066400000000000000000000145551416535272200242160ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.containers.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/field_mask.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/services/containers/v1;containers"; // Containers provides metadata storage for containers used in the execution // service. // // The objects here provide an state-independent view of containers for use in // management and resource pinning. From that perspective, containers do not // have a "state" but rather this is the set of resources that will be // considered in use by the container. // // From the perspective of the execution service, these objects represent the // base parameters for creating a container process. // // In general, when looking to add fields for this type, first ask yourself // whether or not the function of the field has to do with runtime execution or // is invariant of the runtime state of the container. If it has to do with // runtime, or changes as the "container" is started and stops, it probably // doesn't belong on this object. service Containers { rpc Get(GetContainerRequest) returns (GetContainerResponse); rpc List(ListContainersRequest) returns (ListContainersResponse); rpc ListStream(ListContainersRequest) returns (stream ListContainerMessage); rpc Create(CreateContainerRequest) returns (CreateContainerResponse); rpc Update(UpdateContainerRequest) returns (UpdateContainerResponse); rpc Delete(DeleteContainerRequest) returns (google.protobuf.Empty); } message Container { // ID is the user-specified identifier. // // This field may not be updated. string id = 1; // Labels provides an area to include arbitrary data on containers. // // The combined size of a key/value pair cannot exceed 4096 bytes. // // Note that to add a new value to this field, read the existing set and // include the entire result in the update call. map labels = 2; // Image contains the reference of the image used to build the // specification and snapshots for running this container. // // If this field is updated, the spec and rootfs needed to updated, as well. string image = 3; message Runtime { // Name is the name of the runtime. string name = 1; // Options specify additional runtime initialization options. google.protobuf.Any options = 2; } // Runtime specifies which runtime to use for executing this container. Runtime runtime = 4; // Spec to be used when creating the container. This is runtime specific. google.protobuf.Any spec = 5; // Snapshotter specifies the snapshotter name used for rootfs string snapshotter = 6; // SnapshotKey specifies the snapshot key to use for the container's root // filesystem. When starting a task from this container, a caller should // look up the mounts from the snapshot service and include those on the // task create request. // // Snapshots referenced in this field will not be garbage collected. // // This field is set to empty when the rootfs is not a snapshot. // // This field may be updated. string snapshot_key = 7; // CreatedAt is the time the container was first created. google.protobuf.Timestamp created_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // UpdatedAt is the last time the container was mutated. google.protobuf.Timestamp updated_at = 9 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // Extensions allow clients to provide zero or more blobs that are directly // associated with the container. One may provide protobuf, json, or other // encoding formats. The primary use of this is to further decorate the // container object with fields that may be specific to a client integration. // // The key portion of this map should identify a "name" for the extension // that should be unique against other extensions. When updating extension // data, one should only update the specified extension using field paths // to select a specific map key. map extensions = 10 [(gogoproto.nullable) = false]; } message GetContainerRequest { string id = 1; } message GetContainerResponse { Container container = 1 [(gogoproto.nullable) = false]; } message ListContainersRequest { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, containers that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. repeated string filters = 1; } message ListContainersResponse { repeated Container containers = 1 [(gogoproto.nullable) = false]; } message CreateContainerRequest { Container container = 1 [(gogoproto.nullable) = false]; } message CreateContainerResponse { Container container = 1 [(gogoproto.nullable) = false]; } // UpdateContainerRequest updates the metadata on one or more container. // // The operation should follow semantics described in // https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, // unless otherwise qualified. message UpdateContainerRequest { // Container provides the target values, as declared by the mask, for the update. // // The ID field must be set. Container container = 1 [(gogoproto.nullable) = false]; // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. google.protobuf.FieldMask update_mask = 2; } message UpdateContainerResponse { Container container = 1 [(gogoproto.nullable) = false]; } message DeleteContainerRequest { string id = 1; } message ListContainerMessage { Container container = 1; } containerd-1.5.9/api/services/content/000077500000000000000000000000001416535272200177315ustar00rootroot00000000000000containerd-1.5.9/api/services/content/v1/000077500000000000000000000000001416535272200202575ustar00rootroot00000000000000containerd-1.5.9/api/services/content/v1/content.pb.go000066400000000000000000004411011416535272200226610ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/content/v1/content.proto package content import ( context "context" fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // WriteAction defines the behavior of a WriteRequest. type WriteAction int32 const ( // WriteActionStat instructs the writer to return the current status while // holding the lock on the write. WriteActionStat WriteAction = 0 // WriteActionWrite sets the action for the write request to write data. // // Any data included will be written at the provided offset. The // transaction will be left open for further writes. // // This is the default. WriteActionWrite WriteAction = 1 // WriteActionCommit will write any outstanding data in the message and // commit the write, storing it under the digest. // // This can be used in a single message to send the data, verify it and // commit it. // // This action will always terminate the write. WriteActionCommit WriteAction = 2 ) var WriteAction_name = map[int32]string{ 0: "STAT", 1: "WRITE", 2: "COMMIT", } var WriteAction_value = map[string]int32{ "STAT": 0, "WRITE": 1, "COMMIT": 2, } func (x WriteAction) String() string { return proto.EnumName(WriteAction_name, int32(x)) } func (WriteAction) EnumDescriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{0} } type Info struct { // Digest is the hash identity of the blob. Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` // Size is the total number of bytes in the blob. Size_ int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` // CreatedAt provides the time at which the blob was committed. CreatedAt time.Time `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` // UpdatedAt provides the time the info was last updated. UpdatedAt time.Time `protobuf:"bytes,4,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Info) Reset() { *m = Info{} } func (*Info) ProtoMessage() {} func (*Info) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{0} } func (m *Info) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Info) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Info.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Info) XXX_Merge(src proto.Message) { xxx_messageInfo_Info.Merge(m, src) } func (m *Info) XXX_Size() int { return m.Size() } func (m *Info) XXX_DiscardUnknown() { xxx_messageInfo_Info.DiscardUnknown(m) } var xxx_messageInfo_Info proto.InternalMessageInfo type InfoRequest struct { Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *InfoRequest) Reset() { *m = InfoRequest{} } func (*InfoRequest) ProtoMessage() {} func (*InfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{1} } func (m *InfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *InfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_InfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *InfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_InfoRequest.Merge(m, src) } func (m *InfoRequest) XXX_Size() int { return m.Size() } func (m *InfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_InfoRequest.DiscardUnknown(m) } var xxx_messageInfo_InfoRequest proto.InternalMessageInfo type InfoResponse struct { Info Info `protobuf:"bytes,1,opt,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *InfoResponse) Reset() { *m = InfoResponse{} } func (*InfoResponse) ProtoMessage() {} func (*InfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{2} } func (m *InfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *InfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_InfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *InfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_InfoResponse.Merge(m, src) } func (m *InfoResponse) XXX_Size() int { return m.Size() } func (m *InfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_InfoResponse.DiscardUnknown(m) } var xxx_messageInfo_InfoResponse proto.InternalMessageInfo type UpdateRequest struct { Info Info `protobuf:"bytes,1,opt,name=info,proto3" json:"info"` // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // In info, Digest, Size, and CreatedAt are immutable, // other field may be updated using this mask. // If no mask is provided, all mutable field are updated. UpdateMask *types.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateRequest) Reset() { *m = UpdateRequest{} } func (*UpdateRequest) ProtoMessage() {} func (*UpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{3} } func (m *UpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateRequest.Merge(m, src) } func (m *UpdateRequest) XXX_Size() int { return m.Size() } func (m *UpdateRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo type UpdateResponse struct { Info Info `protobuf:"bytes,1,opt,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateResponse) Reset() { *m = UpdateResponse{} } func (*UpdateResponse) ProtoMessage() {} func (*UpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{4} } func (m *UpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateResponse.Merge(m, src) } func (m *UpdateResponse) XXX_Size() int { return m.Size() } func (m *UpdateResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo type ListContentRequest struct { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, containers that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContentRequest) Reset() { *m = ListContentRequest{} } func (*ListContentRequest) ProtoMessage() {} func (*ListContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{5} } func (m *ListContentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContentRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListContentRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContentRequest.Merge(m, src) } func (m *ListContentRequest) XXX_Size() int { return m.Size() } func (m *ListContentRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListContentRequest.DiscardUnknown(m) } var xxx_messageInfo_ListContentRequest proto.InternalMessageInfo type ListContentResponse struct { Info []Info `protobuf:"bytes,1,rep,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContentResponse) Reset() { *m = ListContentResponse{} } func (*ListContentResponse) ProtoMessage() {} func (*ListContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{6} } func (m *ListContentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContentResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListContentResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContentResponse.Merge(m, src) } func (m *ListContentResponse) XXX_Size() int { return m.Size() } func (m *ListContentResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListContentResponse.DiscardUnknown(m) } var xxx_messageInfo_ListContentResponse proto.InternalMessageInfo type DeleteContentRequest struct { // Digest specifies which content to delete. Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteContentRequest) Reset() { *m = DeleteContentRequest{} } func (*DeleteContentRequest) ProtoMessage() {} func (*DeleteContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{7} } func (m *DeleteContentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteContentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteContentRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteContentRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteContentRequest.Merge(m, src) } func (m *DeleteContentRequest) XXX_Size() int { return m.Size() } func (m *DeleteContentRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteContentRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteContentRequest proto.InternalMessageInfo // ReadContentRequest defines the fields that make up a request to read a portion of // data from a stored object. type ReadContentRequest struct { // Digest is the hash identity to read. Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` // Offset specifies the number of bytes from the start at which to begin // the read. If zero or less, the read will be from the start. This uses // standard zero-indexed semantics. Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` // size is the total size of the read. If zero, the entire blob will be // returned by the service. Size_ int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadContentRequest) Reset() { *m = ReadContentRequest{} } func (*ReadContentRequest) ProtoMessage() {} func (*ReadContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{8} } func (m *ReadContentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadContentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadContentRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ReadContentRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadContentRequest.Merge(m, src) } func (m *ReadContentRequest) XXX_Size() int { return m.Size() } func (m *ReadContentRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReadContentRequest.DiscardUnknown(m) } var xxx_messageInfo_ReadContentRequest proto.InternalMessageInfo // ReadContentResponse carries byte data for a read request. type ReadContentResponse struct { Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadContentResponse) Reset() { *m = ReadContentResponse{} } func (*ReadContentResponse) ProtoMessage() {} func (*ReadContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{9} } func (m *ReadContentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadContentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadContentResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ReadContentResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadContentResponse.Merge(m, src) } func (m *ReadContentResponse) XXX_Size() int { return m.Size() } func (m *ReadContentResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReadContentResponse.DiscardUnknown(m) } var xxx_messageInfo_ReadContentResponse proto.InternalMessageInfo type Status struct { StartedAt time.Time `protobuf:"bytes,1,opt,name=started_at,json=startedAt,proto3,stdtime" json:"started_at"` UpdatedAt time.Time `protobuf:"bytes,2,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` Ref string `protobuf:"bytes,3,opt,name=ref,proto3" json:"ref,omitempty"` Offset int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"` Total int64 `protobuf:"varint,5,opt,name=total,proto3" json:"total,omitempty"` Expected github_com_opencontainers_go_digest.Digest `protobuf:"bytes,6,opt,name=expected,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"expected"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Status) Reset() { *m = Status{} } func (*Status) ProtoMessage() {} func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{10} } func (m *Status) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Status.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Status) XXX_Merge(src proto.Message) { xxx_messageInfo_Status.Merge(m, src) } func (m *Status) XXX_Size() int { return m.Size() } func (m *Status) XXX_DiscardUnknown() { xxx_messageInfo_Status.DiscardUnknown(m) } var xxx_messageInfo_Status proto.InternalMessageInfo type StatusRequest struct { Ref string `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatusRequest) Reset() { *m = StatusRequest{} } func (*StatusRequest) ProtoMessage() {} func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{11} } func (m *StatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatusRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusRequest.Merge(m, src) } func (m *StatusRequest) XXX_Size() int { return m.Size() } func (m *StatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_StatusRequest.DiscardUnknown(m) } var xxx_messageInfo_StatusRequest proto.InternalMessageInfo type StatusResponse struct { Status *Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatusResponse) Reset() { *m = StatusResponse{} } func (*StatusResponse) ProtoMessage() {} func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{12} } func (m *StatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatusResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusResponse.Merge(m, src) } func (m *StatusResponse) XXX_Size() int { return m.Size() } func (m *StatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_StatusResponse.DiscardUnknown(m) } var xxx_messageInfo_StatusResponse proto.InternalMessageInfo type ListStatusesRequest struct { Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListStatusesRequest) Reset() { *m = ListStatusesRequest{} } func (*ListStatusesRequest) ProtoMessage() {} func (*ListStatusesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{13} } func (m *ListStatusesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListStatusesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListStatusesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListStatusesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListStatusesRequest.Merge(m, src) } func (m *ListStatusesRequest) XXX_Size() int { return m.Size() } func (m *ListStatusesRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListStatusesRequest.DiscardUnknown(m) } var xxx_messageInfo_ListStatusesRequest proto.InternalMessageInfo type ListStatusesResponse struct { Statuses []Status `protobuf:"bytes,1,rep,name=statuses,proto3" json:"statuses"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListStatusesResponse) Reset() { *m = ListStatusesResponse{} } func (*ListStatusesResponse) ProtoMessage() {} func (*ListStatusesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{14} } func (m *ListStatusesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListStatusesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListStatusesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListStatusesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListStatusesResponse.Merge(m, src) } func (m *ListStatusesResponse) XXX_Size() int { return m.Size() } func (m *ListStatusesResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListStatusesResponse.DiscardUnknown(m) } var xxx_messageInfo_ListStatusesResponse proto.InternalMessageInfo // WriteContentRequest writes data to the request ref at offset. type WriteContentRequest struct { // Action sets the behavior of the write. // // When this is a write and the ref is not yet allocated, the ref will be // allocated and the data will be written at offset. // // If the action is write and the ref is allocated, it will accept data to // an offset that has not yet been written. // // If the action is write and there is no data, the current write status // will be returned. This works differently from status because the stream // holds a lock. Action WriteAction `protobuf:"varint,1,opt,name=action,proto3,enum=containerd.services.content.v1.WriteAction" json:"action,omitempty"` // Ref identifies the pre-commit object to write to. Ref string `protobuf:"bytes,2,opt,name=ref,proto3" json:"ref,omitempty"` // Total can be set to have the service validate the total size of the // committed content. // // The latest value before or with the commit action message will be use to // validate the content. If the offset overflows total, the service may // report an error. It is only required on one message for the write. // // If the value is zero or less, no validation of the final content will be // performed. Total int64 `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"` // Expected can be set to have the service validate the final content against // the provided digest. // // If the digest is already present in the object store, an AlreadyExists // error will be returned. // // Only the latest version will be used to check the content against the // digest. It is only required to include it on a single message, before or // with the commit action message. Expected github_com_opencontainers_go_digest.Digest `protobuf:"bytes,4,opt,name=expected,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"expected"` // Offset specifies the number of bytes from the start at which to begin // the write. For most implementations, this means from the start of the // file. This uses standard, zero-indexed semantics. // // If the action is write, the remote may remove all previously written // data after the offset. Implementations may support arbitrary offsets but // MUST support reseting this value to zero with a write. If an // implementation does not support a write at a particular offset, an // OutOfRange error must be returned. Offset int64 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` // Data is the actual bytes to be written. // // If this is empty and the message is not a commit, a response will be // returned with the current write state. Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteContentRequest) Reset() { *m = WriteContentRequest{} } func (*WriteContentRequest) ProtoMessage() {} func (*WriteContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{15} } func (m *WriteContentRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteContentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteContentRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *WriteContentRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteContentRequest.Merge(m, src) } func (m *WriteContentRequest) XXX_Size() int { return m.Size() } func (m *WriteContentRequest) XXX_DiscardUnknown() { xxx_messageInfo_WriteContentRequest.DiscardUnknown(m) } var xxx_messageInfo_WriteContentRequest proto.InternalMessageInfo // WriteContentResponse is returned on the culmination of a write call. type WriteContentResponse struct { // Action contains the action for the final message of the stream. A writer // should confirm that they match the intended result. Action WriteAction `protobuf:"varint,1,opt,name=action,proto3,enum=containerd.services.content.v1.WriteAction" json:"action,omitempty"` // StartedAt provides the time at which the write began. // // This must be set for stat and commit write actions. All other write // actions may omit this. StartedAt time.Time `protobuf:"bytes,2,opt,name=started_at,json=startedAt,proto3,stdtime" json:"started_at"` // UpdatedAt provides the last time of a successful write. // // This must be set for stat and commit write actions. All other write // actions may omit this. UpdatedAt time.Time `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` // Offset is the current committed size for the write. Offset int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"` // Total provides the current, expected total size of the write. // // We include this to provide consistency with the Status structure on the // client writer. // // This is only valid on the Stat and Commit response. Total int64 `protobuf:"varint,5,opt,name=total,proto3" json:"total,omitempty"` // Digest, if present, includes the digest up to the currently committed // bytes. If action is commit, this field will be set. It is implementation // defined if this is set for other actions. Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,6,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteContentResponse) Reset() { *m = WriteContentResponse{} } func (*WriteContentResponse) ProtoMessage() {} func (*WriteContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{16} } func (m *WriteContentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteContentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteContentResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *WriteContentResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteContentResponse.Merge(m, src) } func (m *WriteContentResponse) XXX_Size() int { return m.Size() } func (m *WriteContentResponse) XXX_DiscardUnknown() { xxx_messageInfo_WriteContentResponse.DiscardUnknown(m) } var xxx_messageInfo_WriteContentResponse proto.InternalMessageInfo type AbortRequest struct { Ref string `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AbortRequest) Reset() { *m = AbortRequest{} } func (*AbortRequest) ProtoMessage() {} func (*AbortRequest) Descriptor() ([]byte, []int) { return fileDescriptor_468430ba3e400391, []int{17} } func (m *AbortRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AbortRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AbortRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *AbortRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AbortRequest.Merge(m, src) } func (m *AbortRequest) XXX_Size() int { return m.Size() } func (m *AbortRequest) XXX_DiscardUnknown() { xxx_messageInfo_AbortRequest.DiscardUnknown(m) } var xxx_messageInfo_AbortRequest proto.InternalMessageInfo func init() { proto.RegisterEnum("containerd.services.content.v1.WriteAction", WriteAction_name, WriteAction_value) proto.RegisterType((*Info)(nil), "containerd.services.content.v1.Info") proto.RegisterMapType((map[string]string)(nil), "containerd.services.content.v1.Info.LabelsEntry") proto.RegisterType((*InfoRequest)(nil), "containerd.services.content.v1.InfoRequest") proto.RegisterType((*InfoResponse)(nil), "containerd.services.content.v1.InfoResponse") proto.RegisterType((*UpdateRequest)(nil), "containerd.services.content.v1.UpdateRequest") proto.RegisterType((*UpdateResponse)(nil), "containerd.services.content.v1.UpdateResponse") proto.RegisterType((*ListContentRequest)(nil), "containerd.services.content.v1.ListContentRequest") proto.RegisterType((*ListContentResponse)(nil), "containerd.services.content.v1.ListContentResponse") proto.RegisterType((*DeleteContentRequest)(nil), "containerd.services.content.v1.DeleteContentRequest") proto.RegisterType((*ReadContentRequest)(nil), "containerd.services.content.v1.ReadContentRequest") proto.RegisterType((*ReadContentResponse)(nil), "containerd.services.content.v1.ReadContentResponse") proto.RegisterType((*Status)(nil), "containerd.services.content.v1.Status") proto.RegisterType((*StatusRequest)(nil), "containerd.services.content.v1.StatusRequest") proto.RegisterType((*StatusResponse)(nil), "containerd.services.content.v1.StatusResponse") proto.RegisterType((*ListStatusesRequest)(nil), "containerd.services.content.v1.ListStatusesRequest") proto.RegisterType((*ListStatusesResponse)(nil), "containerd.services.content.v1.ListStatusesResponse") proto.RegisterType((*WriteContentRequest)(nil), "containerd.services.content.v1.WriteContentRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.content.v1.WriteContentRequest.LabelsEntry") proto.RegisterType((*WriteContentResponse)(nil), "containerd.services.content.v1.WriteContentResponse") proto.RegisterType((*AbortRequest)(nil), "containerd.services.content.v1.AbortRequest") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/content/v1/content.proto", fileDescriptor_468430ba3e400391) } var fileDescriptor_468430ba3e400391 = []byte{ // 1081 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x6f, 0x1b, 0x45, 0x14, 0xf7, 0x78, 0xed, 0x4d, 0xf2, 0x9c, 0x16, 0x33, 0x31, 0x95, 0xb5, 0x08, 0x67, 0xbb, 0x42, 0xc8, 0x6a, 0xc9, 0x3a, 0x75, 0x7a, 0x00, 0x2a, 0x01, 0x8e, 0x9b, 0xaa, 0x41, 0x4d, 0x41, 0x5b, 0x97, 0x40, 0x2f, 0x65, 0x6d, 0x8f, 0xcd, 0x2a, 0xb6, 0xd7, 0xdd, 0x19, 0x5b, 0x84, 0x13, 0x17, 0x24, 0x14, 0xf5, 0x80, 0xb8, 0xe7, 0x02, 0xfc, 0x15, 0x1c, 0x38, 0xe7, 0xc8, 0x11, 0x71, 0x68, 0x69, 0xfe, 0x07, 0xee, 0x68, 0x66, 0x67, 0xed, 0xf5, 0x47, 0x58, 0xdb, 0x31, 0x27, 0xbf, 0x99, 0x7d, 0xbf, 0xf7, 0xfd, 0x31, 0x86, 0x7b, 0x4d, 0x87, 0x7d, 0xdd, 0xab, 0x9a, 0x35, 0xb7, 0x5d, 0xa8, 0xb9, 0x1d, 0x66, 0x3b, 0x1d, 0xe2, 0xd5, 0xc3, 0xa4, 0xdd, 0x75, 0x0a, 0x94, 0x78, 0x7d, 0xa7, 0x46, 0xa8, 0xb8, 0x27, 0x1d, 0x56, 0xe8, 0xdf, 0x0a, 0x48, 0xb3, 0xeb, 0xb9, 0xcc, 0xc5, 0xb9, 0x21, 0xc2, 0x0c, 0xb8, 0xcd, 0x80, 0xa5, 0x7f, 0x4b, 0xcb, 0x34, 0xdd, 0xa6, 0x2b, 0x58, 0x0b, 0x9c, 0xf2, 0x51, 0x9a, 0xde, 0x74, 0xdd, 0x66, 0x8b, 0x14, 0xc4, 0xa9, 0xda, 0x6b, 0x14, 0x1a, 0x0e, 0x69, 0xd5, 0x9f, 0xb6, 0x6d, 0x7a, 0x24, 0x39, 0x36, 0xc7, 0x39, 0x98, 0xd3, 0x26, 0x94, 0xd9, 0xed, 0xae, 0x64, 0x78, 0x73, 0x9c, 0x81, 0xb4, 0xbb, 0xec, 0xd8, 0xff, 0x68, 0xfc, 0x13, 0x87, 0xc4, 0x7e, 0xa7, 0xe1, 0xe2, 0x4f, 0x40, 0xad, 0x3b, 0x4d, 0x42, 0x59, 0x16, 0xe9, 0x28, 0xbf, 0xb6, 0x5b, 0x3c, 0x7b, 0xb1, 0x19, 0xfb, 0xeb, 0xc5, 0xe6, 0x8d, 0x90, 0xfb, 0x6e, 0x97, 0x74, 0x06, 0x5e, 0xd0, 0x42, 0xd3, 0xdd, 0xf2, 0x21, 0xe6, 0x5d, 0xf1, 0x63, 0x49, 0x09, 0x18, 0x43, 0x82, 0x3a, 0xdf, 0x92, 0x6c, 0x5c, 0x47, 0x79, 0xc5, 0x12, 0x34, 0x2e, 0x03, 0xd4, 0x3c, 0x62, 0x33, 0x52, 0x7f, 0x6a, 0xb3, 0xac, 0xa2, 0xa3, 0x7c, 0xaa, 0xa8, 0x99, 0xbe, 0x69, 0x66, 0x60, 0x9a, 0x59, 0x09, 0x6c, 0xdf, 0x5d, 0xe5, 0xfa, 0x7f, 0x7c, 0xb9, 0x89, 0xac, 0x35, 0x89, 0x2b, 0x31, 0x2e, 0xa4, 0xd7, 0xad, 0x07, 0x42, 0x12, 0xf3, 0x08, 0x91, 0xb8, 0x12, 0xc3, 0xf7, 0x41, 0x6d, 0xd9, 0x55, 0xd2, 0xa2, 0xd9, 0xa4, 0xae, 0xe4, 0x53, 0xc5, 0x6d, 0xf3, 0xbf, 0x33, 0x63, 0xf2, 0xf8, 0x98, 0x0f, 0x04, 0x64, 0xaf, 0xc3, 0xbc, 0x63, 0x4b, 0xe2, 0xb5, 0xf7, 0x21, 0x15, 0xba, 0xc6, 0x69, 0x50, 0x8e, 0xc8, 0xb1, 0x1f, 0x3f, 0x8b, 0x93, 0x38, 0x03, 0xc9, 0xbe, 0xdd, 0xea, 0xf9, 0x91, 0x58, 0xb3, 0xfc, 0xc3, 0x07, 0xf1, 0xf7, 0x90, 0xf1, 0x25, 0xa4, 0xb8, 0x58, 0x8b, 0x3c, 0xeb, 0xf1, 0x88, 0x2d, 0x31, 0xfa, 0xc6, 0x43, 0x58, 0xf7, 0x45, 0xd3, 0xae, 0xdb, 0xa1, 0x04, 0x7f, 0x08, 0x09, 0xa7, 0xd3, 0x70, 0x85, 0xe4, 0x54, 0xf1, 0xed, 0x59, 0xbc, 0xdd, 0x4d, 0x70, 0xfd, 0x96, 0xc0, 0x19, 0xcf, 0x11, 0x5c, 0x79, 0x2c, 0xa2, 0x17, 0x58, 0x7b, 0x49, 0x89, 0xf8, 0x0e, 0xa4, 0xfc, 0x74, 0x88, 0x3a, 0x16, 0xc1, 0x99, 0x96, 0xc7, 0x7b, 0xbc, 0xd4, 0x0f, 0x6c, 0x7a, 0x64, 0xc9, 0xac, 0x73, 0xda, 0xf8, 0x0c, 0xae, 0x06, 0xd6, 0x2c, 0xc9, 0x41, 0x13, 0xf0, 0x03, 0x87, 0xb2, 0xb2, 0xcf, 0x12, 0x38, 0x99, 0x85, 0x95, 0x86, 0xd3, 0x62, 0xc4, 0xa3, 0x59, 0xa4, 0x2b, 0xf9, 0x35, 0x2b, 0x38, 0x1a, 0x8f, 0x61, 0x63, 0x84, 0x7f, 0xc2, 0x0c, 0x65, 0x21, 0x33, 0xaa, 0x90, 0xb9, 0x4b, 0x5a, 0x84, 0x91, 0x31, 0x43, 0x96, 0x59, 0x1b, 0xcf, 0x11, 0x60, 0x8b, 0xd8, 0xf5, 0xff, 0x4f, 0x05, 0xbe, 0x06, 0xaa, 0xdb, 0x68, 0x50, 0xc2, 0x64, 0xfb, 0xcb, 0xd3, 0x60, 0x28, 0x28, 0xc3, 0xa1, 0x60, 0x94, 0x60, 0x63, 0xc4, 0x1a, 0x19, 0xc9, 0xa1, 0x08, 0x34, 0x2e, 0xa2, 0x6e, 0x33, 0x5b, 0x08, 0x5e, 0xb7, 0x04, 0x6d, 0xfc, 0x1c, 0x07, 0xf5, 0x11, 0xb3, 0x59, 0x8f, 0xf2, 0xe9, 0x40, 0x99, 0xed, 0xc9, 0xe9, 0x80, 0xe6, 0x99, 0x0e, 0x12, 0x37, 0x31, 0x62, 0xe2, 0x8b, 0x8d, 0x98, 0x34, 0x28, 0x1e, 0x69, 0x08, 0x57, 0xd7, 0x2c, 0x4e, 0x86, 0x5c, 0x4a, 0x8c, 0xb8, 0x94, 0x81, 0x24, 0x73, 0x99, 0xdd, 0xca, 0x26, 0xc5, 0xb5, 0x7f, 0xc0, 0x0f, 0x61, 0x95, 0x7c, 0xd3, 0x25, 0x35, 0x46, 0xea, 0x59, 0x75, 0xe1, 0x8c, 0x0c, 0x64, 0x18, 0xd7, 0xe1, 0x8a, 0x1f, 0xa3, 0x20, 0xe1, 0xd2, 0x40, 0x34, 0x30, 0x90, 0xb7, 0x55, 0xc0, 0x32, 0xa8, 0x67, 0x95, 0x8a, 0x1b, 0x19, 0xca, 0x77, 0xa2, 0x2a, 0x5a, 0xe2, 0x25, 0xca, 0x28, 0xf8, 0x6d, 0xe2, 0xdf, 0x12, 0x1a, 0xdd, 0x57, 0x5f, 0x41, 0x66, 0x14, 0x20, 0x0d, 0xb9, 0x0f, 0xab, 0x54, 0xde, 0xc9, 0xe6, 0x9a, 0xd1, 0x14, 0xd9, 0x5e, 0x03, 0xb4, 0xf1, 0x93, 0x02, 0x1b, 0x87, 0x9e, 0x33, 0xd1, 0x62, 0x65, 0x50, 0xed, 0x1a, 0x73, 0xdc, 0x8e, 0x70, 0xf5, 0x6a, 0xf1, 0x66, 0x94, 0x7c, 0x21, 0xa4, 0x24, 0x20, 0x96, 0x84, 0x06, 0x31, 0x8d, 0x0f, 0x93, 0x3e, 0x48, 0xae, 0x72, 0x51, 0x72, 0x13, 0x97, 0x4f, 0x6e, 0xa8, 0xb4, 0x92, 0x53, 0xbb, 0x45, 0x1d, 0x76, 0x0b, 0x3e, 0x1c, 0xec, 0xbe, 0x15, 0x11, 0xc8, 0x8f, 0x66, 0x72, 0x74, 0x34, 0x5a, 0xcb, 0x5e, 0x85, 0x2f, 0xe3, 0x90, 0x19, 0x55, 0x23, 0xf3, 0xbe, 0x94, 0xac, 0x8c, 0x0e, 0x85, 0xf8, 0x32, 0x86, 0x82, 0xb2, 0xd8, 0x50, 0x98, 0x6f, 0x04, 0x0c, 0x47, 0xb2, 0x7a, 0xe9, 0xa9, 0xaf, 0xc3, 0x7a, 0xa9, 0xea, 0x7a, 0xec, 0xc2, 0xee, 0xbf, 0xf1, 0x3d, 0x82, 0x54, 0x28, 0x7a, 0xf8, 0x2d, 0x48, 0x3c, 0xaa, 0x94, 0x2a, 0xe9, 0x98, 0xb6, 0x71, 0x72, 0xaa, 0xbf, 0x16, 0xfa, 0xc4, 0x3b, 0x0b, 0x6f, 0x42, 0xf2, 0xd0, 0xda, 0xaf, 0xec, 0xa5, 0x91, 0x96, 0x39, 0x39, 0xd5, 0xd3, 0xa1, 0xef, 0x82, 0xc4, 0xd7, 0x41, 0x2d, 0x7f, 0x7a, 0x70, 0xb0, 0x5f, 0x49, 0xc7, 0xb5, 0x37, 0x4e, 0x4e, 0xf5, 0xd7, 0x43, 0x1c, 0x65, 0xb7, 0xdd, 0x76, 0x98, 0xb6, 0xf1, 0xc3, 0x2f, 0xb9, 0xd8, 0x6f, 0xbf, 0xe6, 0xc2, 0x7a, 0x8b, 0xbf, 0xaf, 0xc0, 0x8a, 0x2c, 0x03, 0x6c, 0xcb, 0x97, 0xe9, 0xcd, 0x59, 0x36, 0xa9, 0x74, 0x4d, 0x7b, 0x77, 0x36, 0x66, 0x59, 0x61, 0x4d, 0x50, 0xfd, 0xb7, 0x04, 0xde, 0x8a, 0xc2, 0x8d, 0xbc, 0x80, 0x34, 0x73, 0x56, 0x76, 0xa9, 0xe8, 0x19, 0x24, 0xf8, 0x68, 0xc3, 0xc5, 0x28, 0xdc, 0xe4, 0x43, 0x44, 0xdb, 0x99, 0x0b, 0xe3, 0x2b, 0xdc, 0x46, 0xf8, 0x73, 0x50, 0xfd, 0xe7, 0x04, 0xbe, 0x1d, 0x25, 0x60, 0xda, 0xb3, 0x43, 0xbb, 0x36, 0x51, 0xdf, 0x7b, 0xfc, 0x7f, 0x03, 0x77, 0x85, 0xef, 0xec, 0x68, 0x57, 0x26, 0xdf, 0x19, 0xd1, 0xae, 0x4c, 0x79, 0x0d, 0x6c, 0x23, 0x9e, 0x26, 0xb9, 0xe2, 0xb7, 0x66, 0xdc, 0x41, 0xb3, 0xa6, 0x69, 0x6c, 0xe5, 0x1d, 0xc3, 0x7a, 0x78, 0x03, 0xe1, 0x99, 0x42, 0x3f, 0xb6, 0xe0, 0xb4, 0xdb, 0xf3, 0x81, 0xa4, 0xea, 0x3e, 0x24, 0xfd, 0xd6, 0xd9, 0x59, 0x60, 0x24, 0x47, 0xeb, 0x9c, 0x36, 0x60, 0xf3, 0x68, 0x1b, 0xe1, 0x03, 0x48, 0x8a, 0xd9, 0x80, 0x23, 0x3b, 0x27, 0x3c, 0x42, 0x2e, 0xaa, 0x8e, 0xdd, 0x27, 0x67, 0xaf, 0x72, 0xb1, 0x3f, 0x5f, 0xe5, 0x62, 0xdf, 0x9d, 0xe7, 0xd0, 0xd9, 0x79, 0x0e, 0xfd, 0x71, 0x9e, 0x43, 0x7f, 0x9f, 0xe7, 0xd0, 0x93, 0x8f, 0x17, 0xfd, 0x1f, 0x7d, 0x47, 0x92, 0x5f, 0xc4, 0xaa, 0xaa, 0xd0, 0xb6, 0xf3, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc0, 0xc2, 0x35, 0xb1, 0x94, 0x0f, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // ContentClient is the client API for Content service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ContentClient interface { // Info returns information about a committed object. // // This call can be used for getting the size of content and checking for // existence. Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error) // Update updates content metadata. // // This call can be used to manage the mutable content labels. The // immutable metadata such as digest, size, and committed at cannot // be updated. Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) // List streams the entire set of content as Info objects and closes the // stream. // // Typically, this will yield a large response, chunked into messages. // Clients should make provisions to ensure they can handle the entire data // set. List(ctx context.Context, in *ListContentRequest, opts ...grpc.CallOption) (Content_ListClient, error) // Delete will delete the referenced object. Delete(ctx context.Context, in *DeleteContentRequest, opts ...grpc.CallOption) (*types.Empty, error) // Read allows one to read an object based on the offset into the content. // // The requested data may be returned in one or more messages. Read(ctx context.Context, in *ReadContentRequest, opts ...grpc.CallOption) (Content_ReadClient, error) // Status returns the status for a single reference. Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) // ListStatuses returns the status of ongoing object ingestions, started via // Write. // // Only those matching the regular expression will be provided in the // response. If the provided regular expression is empty, all ingestions // will be provided. ListStatuses(ctx context.Context, in *ListStatusesRequest, opts ...grpc.CallOption) (*ListStatusesResponse, error) // Write begins or resumes writes to a resource identified by a unique ref. // Only one active stream may exist at a time for each ref. // // Once a write stream has started, it may only write to a single ref, thus // once a stream is started, the ref may be omitted on subsequent writes. // // For any write transaction represented by a ref, only a single write may // be made to a given offset. If overlapping writes occur, it is an error. // Writes should be sequential and implementations may throw an error if // this is required. // // If expected_digest is set and already part of the content store, the // write will fail. // // When completed, the commit flag should be set to true. If expected size // or digest is set, the content will be validated against those values. Write(ctx context.Context, opts ...grpc.CallOption) (Content_WriteClient, error) // Abort cancels the ongoing write named in the request. Any resources // associated with the write will be collected. Abort(ctx context.Context, in *AbortRequest, opts ...grpc.CallOption) (*types.Empty, error) } type contentClient struct { cc *grpc.ClientConn } func NewContentClient(cc *grpc.ClientConn) ContentClient { return &contentClient{cc} } func (c *contentClient) Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error) { out := new(InfoResponse) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Info", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *contentClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) { out := new(UpdateResponse) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *contentClient) List(ctx context.Context, in *ListContentRequest, opts ...grpc.CallOption) (Content_ListClient, error) { stream, err := c.cc.NewStream(ctx, &_Content_serviceDesc.Streams[0], "/containerd.services.content.v1.Content/List", opts...) if err != nil { return nil, err } x := &contentListClient{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 Content_ListClient interface { Recv() (*ListContentResponse, error) grpc.ClientStream } type contentListClient struct { grpc.ClientStream } func (x *contentListClient) Recv() (*ListContentResponse, error) { m := new(ListContentResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *contentClient) Delete(ctx context.Context, in *DeleteContentRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *contentClient) Read(ctx context.Context, in *ReadContentRequest, opts ...grpc.CallOption) (Content_ReadClient, error) { stream, err := c.cc.NewStream(ctx, &_Content_serviceDesc.Streams[1], "/containerd.services.content.v1.Content/Read", opts...) if err != nil { return nil, err } x := &contentReadClient{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 Content_ReadClient interface { Recv() (*ReadContentResponse, error) grpc.ClientStream } type contentReadClient struct { grpc.ClientStream } func (x *contentReadClient) Recv() (*ReadContentResponse, error) { m := new(ReadContentResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *contentClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) { out := new(StatusResponse) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Status", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *contentClient) ListStatuses(ctx context.Context, in *ListStatusesRequest, opts ...grpc.CallOption) (*ListStatusesResponse, error) { out := new(ListStatusesResponse) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/ListStatuses", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *contentClient) Write(ctx context.Context, opts ...grpc.CallOption) (Content_WriteClient, error) { stream, err := c.cc.NewStream(ctx, &_Content_serviceDesc.Streams[2], "/containerd.services.content.v1.Content/Write", opts...) if err != nil { return nil, err } x := &contentWriteClient{stream} return x, nil } type Content_WriteClient interface { Send(*WriteContentRequest) error Recv() (*WriteContentResponse, error) grpc.ClientStream } type contentWriteClient struct { grpc.ClientStream } func (x *contentWriteClient) Send(m *WriteContentRequest) error { return x.ClientStream.SendMsg(m) } func (x *contentWriteClient) Recv() (*WriteContentResponse, error) { m := new(WriteContentResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *contentClient) Abort(ctx context.Context, in *AbortRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.content.v1.Content/Abort", in, out, opts...) if err != nil { return nil, err } return out, nil } // ContentServer is the server API for Content service. type ContentServer interface { // Info returns information about a committed object. // // This call can be used for getting the size of content and checking for // existence. Info(context.Context, *InfoRequest) (*InfoResponse, error) // Update updates content metadata. // // This call can be used to manage the mutable content labels. The // immutable metadata such as digest, size, and committed at cannot // be updated. Update(context.Context, *UpdateRequest) (*UpdateResponse, error) // List streams the entire set of content as Info objects and closes the // stream. // // Typically, this will yield a large response, chunked into messages. // Clients should make provisions to ensure they can handle the entire data // set. List(*ListContentRequest, Content_ListServer) error // Delete will delete the referenced object. Delete(context.Context, *DeleteContentRequest) (*types.Empty, error) // Read allows one to read an object based on the offset into the content. // // The requested data may be returned in one or more messages. Read(*ReadContentRequest, Content_ReadServer) error // Status returns the status for a single reference. Status(context.Context, *StatusRequest) (*StatusResponse, error) // ListStatuses returns the status of ongoing object ingestions, started via // Write. // // Only those matching the regular expression will be provided in the // response. If the provided regular expression is empty, all ingestions // will be provided. ListStatuses(context.Context, *ListStatusesRequest) (*ListStatusesResponse, error) // Write begins or resumes writes to a resource identified by a unique ref. // Only one active stream may exist at a time for each ref. // // Once a write stream has started, it may only write to a single ref, thus // once a stream is started, the ref may be omitted on subsequent writes. // // For any write transaction represented by a ref, only a single write may // be made to a given offset. If overlapping writes occur, it is an error. // Writes should be sequential and implementations may throw an error if // this is required. // // If expected_digest is set and already part of the content store, the // write will fail. // // When completed, the commit flag should be set to true. If expected size // or digest is set, the content will be validated against those values. Write(Content_WriteServer) error // Abort cancels the ongoing write named in the request. Any resources // associated with the write will be collected. Abort(context.Context, *AbortRequest) (*types.Empty, error) } // UnimplementedContentServer can be embedded to have forward compatible implementations. type UnimplementedContentServer struct { } func (*UnimplementedContentServer) Info(ctx context.Context, req *InfoRequest) (*InfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Info not implemented") } func (*UnimplementedContentServer) Update(ctx context.Context, req *UpdateRequest) (*UpdateResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedContentServer) List(req *ListContentRequest, srv Content_ListServer) error { return status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedContentServer) Delete(ctx context.Context, req *DeleteContentRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func (*UnimplementedContentServer) Read(req *ReadContentRequest, srv Content_ReadServer) error { return status.Errorf(codes.Unimplemented, "method Read not implemented") } func (*UnimplementedContentServer) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Status not implemented") } func (*UnimplementedContentServer) ListStatuses(ctx context.Context, req *ListStatusesRequest) (*ListStatusesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListStatuses not implemented") } func (*UnimplementedContentServer) Write(srv Content_WriteServer) error { return status.Errorf(codes.Unimplemented, "method Write not implemented") } func (*UnimplementedContentServer) Abort(ctx context.Context, req *AbortRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Abort not implemented") } func RegisterContentServer(s *grpc.Server, srv ContentServer) { s.RegisterService(&_Content_serviceDesc, srv) } func _Content_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(InfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContentServer).Info(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/Info", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).Info(ctx, req.(*InfoRequest)) } return interceptor(ctx, in, info, handler) } func _Content_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.(ContentServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).Update(ctx, req.(*UpdateRequest)) } return interceptor(ctx, in, info, handler) } func _Content_List_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ListContentRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(ContentServer).List(m, &contentListServer{stream}) } type Content_ListServer interface { Send(*ListContentResponse) error grpc.ServerStream } type contentListServer struct { grpc.ServerStream } func (x *contentListServer) Send(m *ListContentResponse) error { return x.ServerStream.SendMsg(m) } func _Content_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteContentRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContentServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).Delete(ctx, req.(*DeleteContentRequest)) } return interceptor(ctx, in, info, handler) } func _Content_Read_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ReadContentRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(ContentServer).Read(m, &contentReadServer{stream}) } type Content_ReadServer interface { Send(*ReadContentResponse) error grpc.ServerStream } type contentReadServer struct { grpc.ServerStream } func (x *contentReadServer) Send(m *ReadContentResponse) error { return x.ServerStream.SendMsg(m) } func _Content_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContentServer).Status(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/Status", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).Status(ctx, req.(*StatusRequest)) } return interceptor(ctx, in, info, handler) } func _Content_ListStatuses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListStatusesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContentServer).ListStatuses(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/ListStatuses", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).ListStatuses(ctx, req.(*ListStatusesRequest)) } return interceptor(ctx, in, info, handler) } func _Content_Write_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ContentServer).Write(&contentWriteServer{stream}) } type Content_WriteServer interface { Send(*WriteContentResponse) error Recv() (*WriteContentRequest, error) grpc.ServerStream } type contentWriteServer struct { grpc.ServerStream } func (x *contentWriteServer) Send(m *WriteContentResponse) error { return x.ServerStream.SendMsg(m) } func (x *contentWriteServer) Recv() (*WriteContentRequest, error) { m := new(WriteContentRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Content_Abort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AbortRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ContentServer).Abort(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.content.v1.Content/Abort", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ContentServer).Abort(ctx, req.(*AbortRequest)) } return interceptor(ctx, in, info, handler) } var _Content_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.content.v1.Content", HandlerType: (*ContentServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Info", Handler: _Content_Info_Handler, }, { MethodName: "Update", Handler: _Content_Update_Handler, }, { MethodName: "Delete", Handler: _Content_Delete_Handler, }, { MethodName: "Status", Handler: _Content_Status_Handler, }, { MethodName: "ListStatuses", Handler: _Content_ListStatuses_Handler, }, { MethodName: "Abort", Handler: _Content_Abort_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "List", Handler: _Content_List_Handler, ServerStreams: true, }, { StreamName: "Read", Handler: _Content_Read_Handler, ServerStreams: true, }, { StreamName: "Write", Handler: _Content_Write_Handler, ServerStreams: true, ClientStreams: true, }, }, Metadata: "github.com/containerd/containerd/api/services/content/v1/content.proto", } func (m *Info) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Info) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintContent(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintContent(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintContent(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x2a } } n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err1 != nil { return 0, err1 } i -= n1 i = encodeVarintContent(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x22 n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintContent(dAtA, i, uint64(n2)) i-- dAtA[i] = 0x1a if m.Size_ != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Size_)) i-- dAtA[i] = 0x10 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *InfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InfoRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *InfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *InfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InfoResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *InfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.UpdateMask != nil { { size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *ListContentRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListContentRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintContent(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ListContentResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListContentResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Info) > 0 { for iNdEx := len(m.Info) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Info[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *DeleteContentRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteContentRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReadContentRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadContentRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ReadContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Size_ != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Size_)) i-- dAtA[i] = 0x18 } if m.Offset != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x10 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReadContentResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadContentResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ReadContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Data) > 0 { i -= len(m.Data) copy(dAtA[i:], m.Data) i = encodeVarintContent(dAtA, i, uint64(len(m.Data))) i-- dAtA[i] = 0x12 } if m.Offset != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *Status) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Status) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Expected) > 0 { i -= len(m.Expected) copy(dAtA[i:], m.Expected) i = encodeVarintContent(dAtA, i, uint64(len(m.Expected))) i-- dAtA[i] = 0x32 } if m.Total != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Total)) i-- dAtA[i] = 0x28 } if m.Offset != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x20 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = encodeVarintContent(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0x1a } n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err7 != nil { return 0, err7 } i -= n7 i = encodeVarintContent(dAtA, i, uint64(n7)) i-- dAtA[i] = 0x12 n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartedAt):]) if err8 != nil { return 0, err8 } i -= n8 i = encodeVarintContent(dAtA, i, uint64(n8)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *StatusRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = encodeVarintContent(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Status != nil { { size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListStatusesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListStatusesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListStatusesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintContent(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ListStatusesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListStatusesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListStatusesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Statuses) > 0 { for iNdEx := len(m.Statuses) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Statuses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintContent(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *WriteContentRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteContentRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WriteContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintContent(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintContent(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintContent(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x3a } } if len(m.Data) > 0 { i -= len(m.Data) copy(dAtA[i:], m.Data) i = encodeVarintContent(dAtA, i, uint64(len(m.Data))) i-- dAtA[i] = 0x32 } if m.Offset != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x28 } if len(m.Expected) > 0 { i -= len(m.Expected) copy(dAtA[i:], m.Expected) i = encodeVarintContent(dAtA, i, uint64(len(m.Expected))) i-- dAtA[i] = 0x22 } if m.Total != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Total)) i-- dAtA[i] = 0x18 } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = encodeVarintContent(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0x12 } if m.Action != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Action)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *WriteContentResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteContentResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WriteContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintContent(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0x32 } if m.Total != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Total)) i-- dAtA[i] = 0x28 } if m.Offset != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Offset)) i-- dAtA[i] = 0x20 } n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err10 != nil { return 0, err10 } i -= n10 i = encodeVarintContent(dAtA, i, uint64(n10)) i-- dAtA[i] = 0x1a n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartedAt):]) if err11 != nil { return 0, err11 } i -= n11 i = encodeVarintContent(dAtA, i, uint64(n11)) i-- dAtA[i] = 0x12 if m.Action != 0 { i = encodeVarintContent(dAtA, i, uint64(m.Action)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *AbortRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AbortRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *AbortRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = encodeVarintContent(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintContent(dAtA []byte, offset int, v uint64) int { offset -= sovContent(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Info) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.Size_ != 0 { n += 1 + sovContent(uint64(m.Size_)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) n += 1 + l + sovContent(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovContent(uint64(l)) if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovContent(uint64(len(k))) + 1 + len(v) + sovContent(uint64(len(v))) n += mapEntrySize + 1 + sovContent(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *InfoRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *InfoResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Info.Size() n += 1 + l + sovContent(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Info.Size() n += 1 + l + sovContent(uint64(l)) if m.UpdateMask != nil { l = m.UpdateMask.Size() n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Info.Size() n += 1 + l + sovContent(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListContentRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovContent(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListContentResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Info) > 0 { for _, e := range m.Info { l = e.Size() n += 1 + l + sovContent(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteContentRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadContentRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.Offset != 0 { n += 1 + sovContent(uint64(m.Offset)) } if m.Size_ != 0 { n += 1 + sovContent(uint64(m.Size_)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadContentResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Offset != 0 { n += 1 + sovContent(uint64(m.Offset)) } l = len(m.Data) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Status) Size() (n int) { if m == nil { return 0 } var l int _ = l l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartedAt) n += 1 + l + sovContent(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovContent(uint64(l)) l = len(m.Ref) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.Offset != 0 { n += 1 + sovContent(uint64(m.Offset)) } if m.Total != 0 { n += 1 + sovContent(uint64(m.Total)) } l = len(m.Expected) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatusResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Status != nil { l = m.Status.Size() n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListStatusesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovContent(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListStatusesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Statuses) > 0 { for _, e := range m.Statuses { l = e.Size() n += 1 + l + sovContent(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteContentRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Action != 0 { n += 1 + sovContent(uint64(m.Action)) } l = len(m.Ref) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.Total != 0 { n += 1 + sovContent(uint64(m.Total)) } l = len(m.Expected) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.Offset != 0 { n += 1 + sovContent(uint64(m.Offset)) } l = len(m.Data) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovContent(uint64(len(k))) + 1 + len(v) + sovContent(uint64(len(v))) n += mapEntrySize + 1 + sovContent(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteContentResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Action != 0 { n += 1 + sovContent(uint64(m.Action)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartedAt) n += 1 + l + sovContent(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovContent(uint64(l)) if m.Offset != 0 { n += 1 + sovContent(uint64(m.Offset)) } if m.Total != 0 { n += 1 + sovContent(uint64(m.Total)) } l = len(m.Digest) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AbortRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ref) if l > 0 { n += 1 + l + sovContent(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovContent(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozContent(x uint64) (n int) { return sovContent(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Info) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&Info{`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *InfoRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&InfoRequest{`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *InfoResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&InfoResponse{`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateRequest{`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types.FieldMask", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateResponse{`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListContentRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListContentRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListContentResponse) String() string { if this == nil { return "nil" } repeatedStringForInfo := "[]Info{" for _, f := range this.Info { repeatedStringForInfo += strings.Replace(strings.Replace(f.String(), "Info", "Info", 1), `&`, ``, 1) + "," } repeatedStringForInfo += "}" s := strings.Join([]string{`&ListContentResponse{`, `Info:` + repeatedStringForInfo + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteContentRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteContentRequest{`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ReadContentRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ReadContentRequest{`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `Offset:` + fmt.Sprintf("%v", this.Offset) + `,`, `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ReadContentResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ReadContentResponse{`, `Offset:` + fmt.Sprintf("%v", this.Offset) + `,`, `Data:` + fmt.Sprintf("%v", this.Data) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Status) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Status{`, `StartedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Ref:` + fmt.Sprintf("%v", this.Ref) + `,`, `Offset:` + fmt.Sprintf("%v", this.Offset) + `,`, `Total:` + fmt.Sprintf("%v", this.Total) + `,`, `Expected:` + fmt.Sprintf("%v", this.Expected) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StatusRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StatusRequest{`, `Ref:` + fmt.Sprintf("%v", this.Ref) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StatusResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StatusResponse{`, `Status:` + strings.Replace(this.Status.String(), "Status", "Status", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListStatusesRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListStatusesRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListStatusesResponse) String() string { if this == nil { return "nil" } repeatedStringForStatuses := "[]Status{" for _, f := range this.Statuses { repeatedStringForStatuses += strings.Replace(strings.Replace(f.String(), "Status", "Status", 1), `&`, ``, 1) + "," } repeatedStringForStatuses += "}" s := strings.Join([]string{`&ListStatusesResponse{`, `Statuses:` + repeatedStringForStatuses + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *WriteContentRequest) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&WriteContentRequest{`, `Action:` + fmt.Sprintf("%v", this.Action) + `,`, `Ref:` + fmt.Sprintf("%v", this.Ref) + `,`, `Total:` + fmt.Sprintf("%v", this.Total) + `,`, `Expected:` + fmt.Sprintf("%v", this.Expected) + `,`, `Offset:` + fmt.Sprintf("%v", this.Offset) + `,`, `Data:` + fmt.Sprintf("%v", this.Data) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *WriteContentResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WriteContentResponse{`, `Action:` + fmt.Sprintf("%v", this.Action) + `,`, `StartedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.StartedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Offset:` + fmt.Sprintf("%v", this.Offset) + `,`, `Total:` + fmt.Sprintf("%v", this.Total) + `,`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *AbortRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&AbortRequest{`, `Ref:` + fmt.Sprintf("%v", this.Ref) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringContent(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Info) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Info: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Info: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= int64(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthContent } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthContent } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthContent } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthContent } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InfoRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *InfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: InfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if m.UpdateMask == nil { m.UpdateMask = &types.FieldMask{} } if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListContentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListContentRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContentRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Info = append(m.Info, Info{}) if err := m.Info[len(m.Info)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteContentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteContentRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteContentRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadContentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadContentRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadContentRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= int64(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ReadContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ReadContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Status) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Status: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) } m.Total = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Total |= int64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Expected", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Expected = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatusRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatusResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if m.Status == nil { m.Status = &Status{} } if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListStatusesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListStatusesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListStatusesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListStatusesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListStatusesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListStatusesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Statuses = append(m.Statuses, Status{}) if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WriteContentRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WriteContentRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteContentRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) } m.Action = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Action |= WriteAction(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) } m.Total = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Total |= int64(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Expected", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Expected = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthContent } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthContent } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthContent } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthContent } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WriteContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WriteContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) } m.Action = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Action |= WriteAction(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) } m.Offset = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Offset |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) } m.Total = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Total |= int64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *AbortRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: AbortRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AbortRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowContent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthContent } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthContent } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipContent(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthContent } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipContent(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowContent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthContent } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupContent } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthContent } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthContent = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowContent = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupContent = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/content/v1/content.proto000066400000000000000000000276351416535272200230330ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.content.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/field_mask.proto"; import "google/protobuf/timestamp.proto"; import "google/protobuf/empty.proto"; option go_package = "github.com/containerd/containerd/api/services/content/v1;content"; // Content provides access to a content addressable storage system. service Content { // Info returns information about a committed object. // // This call can be used for getting the size of content and checking for // existence. rpc Info(InfoRequest) returns (InfoResponse); // Update updates content metadata. // // This call can be used to manage the mutable content labels. The // immutable metadata such as digest, size, and committed at cannot // be updated. rpc Update(UpdateRequest) returns (UpdateResponse); // List streams the entire set of content as Info objects and closes the // stream. // // Typically, this will yield a large response, chunked into messages. // Clients should make provisions to ensure they can handle the entire data // set. rpc List(ListContentRequest) returns (stream ListContentResponse); // Delete will delete the referenced object. rpc Delete(DeleteContentRequest) returns (google.protobuf.Empty); // Read allows one to read an object based on the offset into the content. // // The requested data may be returned in one or more messages. rpc Read(ReadContentRequest) returns (stream ReadContentResponse); // Status returns the status for a single reference. rpc Status(StatusRequest) returns (StatusResponse); // ListStatuses returns the status of ongoing object ingestions, started via // Write. // // Only those matching the regular expression will be provided in the // response. If the provided regular expression is empty, all ingestions // will be provided. rpc ListStatuses(ListStatusesRequest) returns (ListStatusesResponse); // Write begins or resumes writes to a resource identified by a unique ref. // Only one active stream may exist at a time for each ref. // // Once a write stream has started, it may only write to a single ref, thus // once a stream is started, the ref may be omitted on subsequent writes. // // For any write transaction represented by a ref, only a single write may // be made to a given offset. If overlapping writes occur, it is an error. // Writes should be sequential and implementations may throw an error if // this is required. // // If expected_digest is set and already part of the content store, the // write will fail. // // When completed, the commit flag should be set to true. If expected size // or digest is set, the content will be validated against those values. rpc Write(stream WriteContentRequest) returns (stream WriteContentResponse); // Abort cancels the ongoing write named in the request. Any resources // associated with the write will be collected. rpc Abort(AbortRequest) returns (google.protobuf.Empty); } message Info { // Digest is the hash identity of the blob. string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; // Size is the total number of bytes in the blob. int64 size = 2; // CreatedAt provides the time at which the blob was committed. google.protobuf.Timestamp created_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // UpdatedAt provides the time the info was last updated. google.protobuf.Timestamp updated_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 5; } message InfoRequest { string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; } message InfoResponse { Info info = 1 [(gogoproto.nullable) = false]; } message UpdateRequest { Info info = 1 [(gogoproto.nullable) = false]; // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // In info, Digest, Size, and CreatedAt are immutable, // other field may be updated using this mask. // If no mask is provided, all mutable field are updated. google.protobuf.FieldMask update_mask = 2; } message UpdateResponse { Info info = 1 [(gogoproto.nullable) = false]; } message ListContentRequest { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, containers that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. repeated string filters = 1; } message ListContentResponse { repeated Info info = 1 [(gogoproto.nullable) = false]; } message DeleteContentRequest { // Digest specifies which content to delete. string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; } // ReadContentRequest defines the fields that make up a request to read a portion of // data from a stored object. message ReadContentRequest { // Digest is the hash identity to read. string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; // Offset specifies the number of bytes from the start at which to begin // the read. If zero or less, the read will be from the start. This uses // standard zero-indexed semantics. int64 offset = 2; // size is the total size of the read. If zero, the entire blob will be // returned by the service. int64 size = 3; } // ReadContentResponse carries byte data for a read request. message ReadContentResponse { int64 offset = 1; // offset of the returned data bytes data = 2; // actual data } message Status { google.protobuf.Timestamp started_at = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp updated_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; string ref = 3; int64 offset = 4; int64 total = 5; string expected = 6 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; } message StatusRequest { string ref = 1; } message StatusResponse { Status status = 1; } message ListStatusesRequest { repeated string filters = 1; } message ListStatusesResponse { repeated Status statuses = 1 [(gogoproto.nullable) = false]; } // WriteAction defines the behavior of a WriteRequest. enum WriteAction { option (gogoproto.goproto_enum_prefix) = false; option (gogoproto.enum_customname) = "WriteAction"; // WriteActionStat instructs the writer to return the current status while // holding the lock on the write. STAT = 0 [(gogoproto.enumvalue_customname) = "WriteActionStat"]; // WriteActionWrite sets the action for the write request to write data. // // Any data included will be written at the provided offset. The // transaction will be left open for further writes. // // This is the default. WRITE = 1 [(gogoproto.enumvalue_customname) = "WriteActionWrite"]; // WriteActionCommit will write any outstanding data in the message and // commit the write, storing it under the digest. // // This can be used in a single message to send the data, verify it and // commit it. // // This action will always terminate the write. COMMIT = 2 [(gogoproto.enumvalue_customname) = "WriteActionCommit"]; } // WriteContentRequest writes data to the request ref at offset. message WriteContentRequest { // Action sets the behavior of the write. // // When this is a write and the ref is not yet allocated, the ref will be // allocated and the data will be written at offset. // // If the action is write and the ref is allocated, it will accept data to // an offset that has not yet been written. // // If the action is write and there is no data, the current write status // will be returned. This works differently from status because the stream // holds a lock. WriteAction action = 1; // Ref identifies the pre-commit object to write to. string ref = 2; // Total can be set to have the service validate the total size of the // committed content. // // The latest value before or with the commit action message will be use to // validate the content. If the offset overflows total, the service may // report an error. It is only required on one message for the write. // // If the value is zero or less, no validation of the final content will be // performed. int64 total = 3; // Expected can be set to have the service validate the final content against // the provided digest. // // If the digest is already present in the object store, an AlreadyExists // error will be returned. // // Only the latest version will be used to check the content against the // digest. It is only required to include it on a single message, before or // with the commit action message. string expected = 4 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; // Offset specifies the number of bytes from the start at which to begin // the write. For most implementations, this means from the start of the // file. This uses standard, zero-indexed semantics. // // If the action is write, the remote may remove all previously written // data after the offset. Implementations may support arbitrary offsets but // MUST support reseting this value to zero with a write. If an // implementation does not support a write at a particular offset, an // OutOfRange error must be returned. int64 offset = 5; // Data is the actual bytes to be written. // // If this is empty and the message is not a commit, a response will be // returned with the current write state. bytes data = 6; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 7; } // WriteContentResponse is returned on the culmination of a write call. message WriteContentResponse { // Action contains the action for the final message of the stream. A writer // should confirm that they match the intended result. WriteAction action = 1; // StartedAt provides the time at which the write began. // // This must be set for stat and commit write actions. All other write // actions may omit this. google.protobuf.Timestamp started_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // UpdatedAt provides the last time of a successful write. // // This must be set for stat and commit write actions. All other write // actions may omit this. google.protobuf.Timestamp updated_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // Offset is the current committed size for the write. int64 offset = 4; // Total provides the current, expected total size of the write. // // We include this to provide consistency with the Status structure on the // client writer. // // This is only valid on the Stat and Commit response. int64 total = 5; // Digest, if present, includes the digest up to the currently committed // bytes. If action is commit, this field will be set. It is implementation // defined if this is set for other actions. string digest = 6 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; } message AbortRequest { string ref = 1; } containerd-1.5.9/api/services/diff/000077500000000000000000000000001416535272200171675ustar00rootroot00000000000000containerd-1.5.9/api/services/diff/v1/000077500000000000000000000000001416535272200175155ustar00rootroot00000000000000containerd-1.5.9/api/services/diff/v1/diff.pb.go000066400000000000000000001266011416535272200213620ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/diff/v1/diff.proto package diff import ( context "context" fmt "fmt" types "github.com/containerd/containerd/api/types" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" types1 "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ApplyRequest struct { // Diff is the descriptor of the diff to be extracted Diff *types.Descriptor `protobuf:"bytes,1,opt,name=diff,proto3" json:"diff,omitempty"` Mounts []*types.Mount `protobuf:"bytes,2,rep,name=mounts,proto3" json:"mounts,omitempty"` Payloads map[string]*types1.Any `protobuf:"bytes,3,rep,name=payloads,proto3" json:"payloads,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ApplyRequest) Reset() { *m = ApplyRequest{} } func (*ApplyRequest) ProtoMessage() {} func (*ApplyRequest) Descriptor() ([]byte, []int) { return fileDescriptor_3b36a99e6faaa935, []int{0} } func (m *ApplyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ApplyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ApplyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ApplyRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ApplyRequest.Merge(m, src) } func (m *ApplyRequest) XXX_Size() int { return m.Size() } func (m *ApplyRequest) XXX_DiscardUnknown() { xxx_messageInfo_ApplyRequest.DiscardUnknown(m) } var xxx_messageInfo_ApplyRequest proto.InternalMessageInfo type ApplyResponse struct { // Applied is the descriptor for the object which was applied. // If the input was a compressed blob then the result will be // the descriptor for the uncompressed blob. Applied *types.Descriptor `protobuf:"bytes,1,opt,name=applied,proto3" json:"applied,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ApplyResponse) Reset() { *m = ApplyResponse{} } func (*ApplyResponse) ProtoMessage() {} func (*ApplyResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3b36a99e6faaa935, []int{1} } func (m *ApplyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ApplyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ApplyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ApplyResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ApplyResponse.Merge(m, src) } func (m *ApplyResponse) XXX_Size() int { return m.Size() } func (m *ApplyResponse) XXX_DiscardUnknown() { xxx_messageInfo_ApplyResponse.DiscardUnknown(m) } var xxx_messageInfo_ApplyResponse proto.InternalMessageInfo type DiffRequest struct { // Left are the mounts which represent the older copy // in which is the base of the computed changes. Left []*types.Mount `protobuf:"bytes,1,rep,name=left,proto3" json:"left,omitempty"` // Right are the mounts which represents the newer copy // in which changes from the left were made into. Right []*types.Mount `protobuf:"bytes,2,rep,name=right,proto3" json:"right,omitempty"` // MediaType is the media type descriptor for the created diff // object MediaType string `protobuf:"bytes,3,opt,name=media_type,json=mediaType,proto3" json:"media_type,omitempty"` // Ref identifies the pre-commit content store object. This // reference can be used to get the status from the content store. Ref string `protobuf:"bytes,4,opt,name=ref,proto3" json:"ref,omitempty"` // Labels are the labels to apply to the generated content // on content store commit. Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DiffRequest) Reset() { *m = DiffRequest{} } func (*DiffRequest) ProtoMessage() {} func (*DiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor_3b36a99e6faaa935, []int{2} } func (m *DiffRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DiffRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DiffRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DiffRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DiffRequest.Merge(m, src) } func (m *DiffRequest) XXX_Size() int { return m.Size() } func (m *DiffRequest) XXX_DiscardUnknown() { xxx_messageInfo_DiffRequest.DiscardUnknown(m) } var xxx_messageInfo_DiffRequest proto.InternalMessageInfo type DiffResponse struct { // Diff is the descriptor of the diff which can be applied Diff *types.Descriptor `protobuf:"bytes,3,opt,name=diff,proto3" json:"diff,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DiffResponse) Reset() { *m = DiffResponse{} } func (*DiffResponse) ProtoMessage() {} func (*DiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor_3b36a99e6faaa935, []int{3} } func (m *DiffResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DiffResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DiffResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DiffResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DiffResponse.Merge(m, src) } func (m *DiffResponse) XXX_Size() int { return m.Size() } func (m *DiffResponse) XXX_DiscardUnknown() { xxx_messageInfo_DiffResponse.DiscardUnknown(m) } var xxx_messageInfo_DiffResponse proto.InternalMessageInfo func init() { proto.RegisterType((*ApplyRequest)(nil), "containerd.services.diff.v1.ApplyRequest") proto.RegisterMapType((map[string]*types1.Any)(nil), "containerd.services.diff.v1.ApplyRequest.PayloadsEntry") proto.RegisterType((*ApplyResponse)(nil), "containerd.services.diff.v1.ApplyResponse") proto.RegisterType((*DiffRequest)(nil), "containerd.services.diff.v1.DiffRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.diff.v1.DiffRequest.LabelsEntry") proto.RegisterType((*DiffResponse)(nil), "containerd.services.diff.v1.DiffResponse") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/diff/v1/diff.proto", fileDescriptor_3b36a99e6faaa935) } var fileDescriptor_3b36a99e6faaa935 = []byte{ // 526 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x41, 0x6f, 0xd3, 0x4c, 0x10, 0x8d, 0xed, 0x24, 0xdf, 0x97, 0x49, 0x2b, 0xa1, 0x55, 0x24, 0x8c, 0x01, 0xab, 0xca, 0x29, 0x2d, 0x62, 0x4d, 0x03, 0x2a, 0xd0, 0x5e, 0x5a, 0x54, 0xc4, 0xa5, 0x48, 0x60, 0x7a, 0x40, 0x20, 0x81, 0x9c, 0x78, 0xed, 0xae, 0x70, 0xbc, 0x8b, 0x77, 0x1d, 0xc9, 0x37, 0xfe, 0x06, 0x67, 0x7e, 0x0a, 0x97, 0x1e, 0x39, 0x72, 0xa4, 0xf9, 0x25, 0xc8, 0xeb, 0x75, 0x31, 0x02, 0x05, 0xc3, 0xc9, 0x9b, 0x9d, 0xf7, 0xde, 0xce, 0xbc, 0x37, 0x0a, 0x1c, 0xc6, 0x54, 0x9e, 0xe5, 0x33, 0x3c, 0x67, 0x0b, 0x6f, 0xce, 0x52, 0x19, 0xd0, 0x94, 0x64, 0x61, 0xf3, 0x18, 0x70, 0xea, 0x09, 0x92, 0x2d, 0xe9, 0x9c, 0x08, 0x2f, 0xa4, 0x51, 0xe4, 0x2d, 0x77, 0xd5, 0x17, 0xf3, 0x8c, 0x49, 0x86, 0xae, 0xff, 0xc0, 0xe2, 0x1a, 0x87, 0x55, 0x7d, 0xb9, 0xeb, 0x8c, 0x62, 0x16, 0x33, 0x85, 0xf3, 0xca, 0x53, 0x45, 0x71, 0xae, 0xc5, 0x8c, 0xc5, 0x09, 0xf1, 0xd4, 0xaf, 0x59, 0x1e, 0x79, 0x41, 0x5a, 0xe8, 0xd2, 0x5e, 0xab, 0x7e, 0x64, 0xc1, 0x89, 0xf0, 0x16, 0x2c, 0x4f, 0xa5, 0xe6, 0x1d, 0xfc, 0x05, 0x2f, 0x24, 0x62, 0x9e, 0x51, 0x2e, 0x59, 0x56, 0x91, 0xc7, 0x1f, 0x4d, 0xd8, 0x38, 0xe2, 0x3c, 0x29, 0x7c, 0xf2, 0x3e, 0x27, 0x42, 0xa2, 0x3b, 0xd0, 0x2d, 0x27, 0xb0, 0x8d, 0x2d, 0x63, 0x32, 0x9c, 0xde, 0xc0, 0x8d, 0x11, 0x95, 0x04, 0x3e, 0xbe, 0x94, 0xf0, 0x15, 0x12, 0x79, 0xd0, 0x57, 0xed, 0x08, 0xdb, 0xdc, 0xb2, 0x26, 0xc3, 0xe9, 0xd5, 0x5f, 0x39, 0x4f, 0xcb, 0xba, 0xaf, 0x61, 0xe8, 0x05, 0xfc, 0xcf, 0x83, 0x22, 0x61, 0x41, 0x28, 0x6c, 0x4b, 0x51, 0xee, 0xe3, 0x35, 0x4e, 0xe2, 0x66, 0x7f, 0xf8, 0x99, 0x66, 0x3e, 0x4e, 0x65, 0x56, 0xf8, 0x97, 0x42, 0xce, 0x73, 0xd8, 0xfc, 0xa9, 0x84, 0xae, 0x80, 0xf5, 0x8e, 0x14, 0x6a, 0x8e, 0x81, 0x5f, 0x1e, 0xd1, 0x0e, 0xf4, 0x96, 0x41, 0x92, 0x13, 0xdb, 0x54, 0xb3, 0x8d, 0x70, 0x95, 0x05, 0xae, 0xb3, 0xc0, 0x47, 0x69, 0xe1, 0x57, 0x90, 0x7d, 0xf3, 0x81, 0x31, 0x7e, 0x02, 0x9b, 0xfa, 0x69, 0xc1, 0x59, 0x2a, 0x08, 0xda, 0x83, 0xff, 0x02, 0xce, 0x13, 0x4a, 0xc2, 0x56, 0xf6, 0xd4, 0xe0, 0xf1, 0x27, 0x13, 0x86, 0xc7, 0x34, 0x8a, 0x6a, 0x8f, 0x6f, 0x41, 0x37, 0x21, 0x91, 0xb4, 0x8d, 0xf5, 0x7e, 0x29, 0x10, 0xba, 0x0d, 0xbd, 0x8c, 0xc6, 0x67, 0xf2, 0x4f, 0xee, 0x56, 0x28, 0x74, 0x13, 0x60, 0x41, 0x42, 0x1a, 0xbc, 0x2d, 0x6b, 0xb6, 0xa5, 0xa6, 0x1f, 0xa8, 0x9b, 0xd3, 0x82, 0x93, 0xd2, 0x95, 0x8c, 0x44, 0x76, 0xb7, 0x72, 0x25, 0x23, 0x11, 0x3a, 0x81, 0x7e, 0x12, 0xcc, 0x48, 0x22, 0xec, 0x9e, 0x7a, 0xe0, 0xde, 0xda, 0x2c, 0x1a, 0x63, 0xe0, 0x13, 0x45, 0xab, 0x82, 0xd0, 0x1a, 0xce, 0x43, 0x18, 0x36, 0xae, 0x7f, 0x13, 0xc2, 0xa8, 0x19, 0xc2, 0xa0, 0x69, 0xf7, 0x21, 0x6c, 0x54, 0xea, 0xda, 0xed, 0x7a, 0x13, 0xad, 0xb6, 0x9b, 0x38, 0xfd, 0x6c, 0x40, 0xb7, 0x94, 0x40, 0x6f, 0xa0, 0xa7, 0x92, 0x43, 0xdb, 0xad, 0x17, 0xcb, 0xd9, 0x69, 0x03, 0xd5, 0xad, 0xbd, 0xd6, 0xef, 0x4c, 0xda, 0x7a, 0xe5, 0x6c, 0xb7, 0x40, 0x56, 0xe2, 0x8f, 0x4e, 0xcf, 0x2f, 0xdc, 0xce, 0xd7, 0x0b, 0xb7, 0xf3, 0x61, 0xe5, 0x1a, 0xe7, 0x2b, 0xd7, 0xf8, 0xb2, 0x72, 0x8d, 0x6f, 0x2b, 0xd7, 0x78, 0xb5, 0xff, 0x4f, 0xff, 0x58, 0x07, 0xe5, 0xf7, 0x65, 0x67, 0xd6, 0x57, 0x7b, 0x7e, 0xf7, 0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x85, 0x25, 0xb8, 0xf8, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // DiffClient is the client API for Diff service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type DiffClient interface { // Apply applies the content associated with the provided digests onto // the provided mounts. Archive content will be extracted and // decompressed if necessary. Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) // Diff creates a diff between the given mounts and uploads the result // to the content store. Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (*DiffResponse, error) } type diffClient struct { cc *grpc.ClientConn } func NewDiffClient(cc *grpc.ClientConn) DiffClient { return &diffClient{cc} } func (c *diffClient) Apply(ctx context.Context, in *ApplyRequest, opts ...grpc.CallOption) (*ApplyResponse, error) { out := new(ApplyResponse) err := c.cc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Apply", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *diffClient) Diff(ctx context.Context, in *DiffRequest, opts ...grpc.CallOption) (*DiffResponse, error) { out := new(DiffResponse) err := c.cc.Invoke(ctx, "/containerd.services.diff.v1.Diff/Diff", in, out, opts...) if err != nil { return nil, err } return out, nil } // DiffServer is the server API for Diff service. type DiffServer interface { // Apply applies the content associated with the provided digests onto // the provided mounts. Archive content will be extracted and // decompressed if necessary. Apply(context.Context, *ApplyRequest) (*ApplyResponse, error) // Diff creates a diff between the given mounts and uploads the result // to the content store. Diff(context.Context, *DiffRequest) (*DiffResponse, error) } // UnimplementedDiffServer can be embedded to have forward compatible implementations. type UnimplementedDiffServer struct { } func (*UnimplementedDiffServer) Apply(ctx context.Context, req *ApplyRequest) (*ApplyResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Apply not implemented") } func (*UnimplementedDiffServer) Diff(ctx context.Context, req *DiffRequest) (*DiffResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Diff not implemented") } func RegisterDiffServer(s *grpc.Server, srv DiffServer) { s.RegisterService(&_Diff_serviceDesc, srv) } func _Diff_Apply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ApplyRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DiffServer).Apply(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.diff.v1.Diff/Apply", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DiffServer).Apply(ctx, req.(*ApplyRequest)) } return interceptor(ctx, in, info, handler) } func _Diff_Diff_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DiffRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DiffServer).Diff(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.diff.v1.Diff/Diff", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DiffServer).Diff(ctx, req.(*DiffRequest)) } return interceptor(ctx, in, info, handler) } var _Diff_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.diff.v1.Diff", HandlerType: (*DiffServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Apply", Handler: _Diff_Apply_Handler, }, { MethodName: "Diff", Handler: _Diff_Diff_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/diff/v1/diff.proto", } func (m *ApplyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ApplyRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ApplyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Payloads) > 0 { for k := range m.Payloads { v := m.Payloads[k] baseI := i if v != nil { { size, err := v.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } i -= len(k) copy(dAtA[i:], k) i = encodeVarintDiff(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintDiff(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } } if m.Diff != nil { { size, err := m.Diff.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ApplyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ApplyResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ApplyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Applied != nil { { size, err := m.Applied.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DiffRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DiffRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DiffRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintDiff(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintDiff(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintDiff(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x2a } } if len(m.Ref) > 0 { i -= len(m.Ref) copy(dAtA[i:], m.Ref) i = encodeVarintDiff(dAtA, i, uint64(len(m.Ref))) i-- dAtA[i] = 0x22 } if len(m.MediaType) > 0 { i -= len(m.MediaType) copy(dAtA[i:], m.MediaType) i = encodeVarintDiff(dAtA, i, uint64(len(m.MediaType))) i-- dAtA[i] = 0x1a } if len(m.Right) > 0 { for iNdEx := len(m.Right) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Right[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } } if len(m.Left) > 0 { for iNdEx := len(m.Left) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Left[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *DiffResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DiffResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DiffResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Diff != nil { { size, err := m.Diff.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintDiff(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil } func encodeVarintDiff(dAtA []byte, offset int, v uint64) int { offset -= sovDiff(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *ApplyRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Diff != nil { l = m.Diff.Size() n += 1 + l + sovDiff(uint64(l)) } if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovDiff(uint64(l)) } } if len(m.Payloads) > 0 { for k, v := range m.Payloads { _ = k _ = v l = 0 if v != nil { l = v.Size() l += 1 + sovDiff(uint64(l)) } mapEntrySize := 1 + len(k) + sovDiff(uint64(len(k))) + l n += mapEntrySize + 1 + sovDiff(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ApplyResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Applied != nil { l = m.Applied.Size() n += 1 + l + sovDiff(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DiffRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Left) > 0 { for _, e := range m.Left { l = e.Size() n += 1 + l + sovDiff(uint64(l)) } } if len(m.Right) > 0 { for _, e := range m.Right { l = e.Size() n += 1 + l + sovDiff(uint64(l)) } } l = len(m.MediaType) if l > 0 { n += 1 + l + sovDiff(uint64(l)) } l = len(m.Ref) if l > 0 { n += 1 + l + sovDiff(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovDiff(uint64(len(k))) + 1 + len(v) + sovDiff(uint64(len(v))) n += mapEntrySize + 1 + sovDiff(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DiffResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Diff != nil { l = m.Diff.Size() n += 1 + l + sovDiff(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovDiff(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozDiff(x uint64) (n int) { return sovDiff(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *ApplyRequest) String() string { if this == nil { return "nil" } repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForMounts += "}" keysForPayloads := make([]string, 0, len(this.Payloads)) for k, _ := range this.Payloads { keysForPayloads = append(keysForPayloads, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForPayloads) mapStringForPayloads := "map[string]*types1.Any{" for _, k := range keysForPayloads { mapStringForPayloads += fmt.Sprintf("%v: %v,", k, this.Payloads[k]) } mapStringForPayloads += "}" s := strings.Join([]string{`&ApplyRequest{`, `Diff:` + strings.Replace(fmt.Sprintf("%v", this.Diff), "Descriptor", "types.Descriptor", 1) + `,`, `Mounts:` + repeatedStringForMounts + `,`, `Payloads:` + mapStringForPayloads + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ApplyResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ApplyResponse{`, `Applied:` + strings.Replace(fmt.Sprintf("%v", this.Applied), "Descriptor", "types.Descriptor", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DiffRequest) String() string { if this == nil { return "nil" } repeatedStringForLeft := "[]*Mount{" for _, f := range this.Left { repeatedStringForLeft += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForLeft += "}" repeatedStringForRight := "[]*Mount{" for _, f := range this.Right { repeatedStringForRight += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForRight += "}" keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&DiffRequest{`, `Left:` + repeatedStringForLeft + `,`, `Right:` + repeatedStringForRight + `,`, `MediaType:` + fmt.Sprintf("%v", this.MediaType) + `,`, `Ref:` + fmt.Sprintf("%v", this.Ref) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DiffResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DiffResponse{`, `Diff:` + strings.Replace(fmt.Sprintf("%v", this.Diff), "Descriptor", "types.Descriptor", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringDiff(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *ApplyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ApplyRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ApplyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Diff", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } if m.Diff == nil { m.Diff = &types.Descriptor{} } if err := m.Diff.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &types.Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Payloads", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } if m.Payloads == nil { m.Payloads = make(map[string]*types1.Any) } var mapkey string var mapvalue *types1.Any for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthDiff } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthDiff } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return ErrInvalidLengthDiff } postmsgIndex := iNdEx + mapmsglen if postmsgIndex < 0 { return ErrInvalidLengthDiff } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &types1.Any{} if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Payloads[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ApplyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ApplyResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ApplyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Applied", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } if m.Applied == nil { m.Applied = &types.Descriptor{} } if err := m.Applied.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DiffRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DiffRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DiffRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } m.Left = append(m.Left, &types.Mount{}) if err := m.Left[len(m.Left)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } m.Right = append(m.Right, &types.Mount{}) if err := m.Right[len(m.Right)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MediaType", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } m.MediaType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } m.Ref = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthDiff } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthDiff } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthDiff } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthDiff } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DiffResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DiffResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DiffResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Diff", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiff } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiff } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDiff } if postIndex > l { return io.ErrUnexpectedEOF } if m.Diff == nil { m.Diff = &types.Descriptor{} } if err := m.Diff.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiff(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDiff } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipDiff(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiff } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiff } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiff } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthDiff } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupDiff } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthDiff } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthDiff = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowDiff = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupDiff = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/diff/v1/diff.proto000066400000000000000000000050751416535272200215210ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.diff.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; import "github.com/containerd/containerd/api/types/mount.proto"; import "github.com/containerd/containerd/api/types/descriptor.proto"; option go_package = "github.com/containerd/containerd/api/services/diff/v1;diff"; // Diff service creates and applies diffs service Diff { // Apply applies the content associated with the provided digests onto // the provided mounts. Archive content will be extracted and // decompressed if necessary. rpc Apply(ApplyRequest) returns (ApplyResponse); // Diff creates a diff between the given mounts and uploads the result // to the content store. rpc Diff(DiffRequest) returns (DiffResponse); } message ApplyRequest { // Diff is the descriptor of the diff to be extracted containerd.types.Descriptor diff = 1; repeated containerd.types.Mount mounts = 2; map payloads = 3; } message ApplyResponse { // Applied is the descriptor for the object which was applied. // If the input was a compressed blob then the result will be // the descriptor for the uncompressed blob. containerd.types.Descriptor applied = 1; } message DiffRequest { // Left are the mounts which represent the older copy // in which is the base of the computed changes. repeated containerd.types.Mount left = 1; // Right are the mounts which represents the newer copy // in which changes from the left were made into. repeated containerd.types.Mount right = 2; // MediaType is the media type descriptor for the created diff // object string media_type = 3; // Ref identifies the pre-commit content store object. This // reference can be used to get the status from the content store. string ref = 4; // Labels are the labels to apply to the generated content // on content store commit. map labels = 5; } message DiffResponse { // Diff is the descriptor of the diff which can be applied containerd.types.Descriptor diff = 3; } containerd-1.5.9/api/services/events/000077500000000000000000000000001416535272200175635ustar00rootroot00000000000000containerd-1.5.9/api/services/events/v1/000077500000000000000000000000001416535272200201115ustar00rootroot00000000000000containerd-1.5.9/api/services/events/v1/doc.go000066400000000000000000000012511416535272200212040ustar00rootroot00000000000000/* Copyright The containerd 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 events defines the event pushing and subscription service. package events containerd-1.5.9/api/services/events/v1/events.pb.go000066400000000000000000001107271416535272200223540ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/events/v1/events.proto package events import ( context "context" fmt "fmt" github_com_containerd_typeurl "github.com/containerd/typeurl" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type PublishRequest struct { Topic string `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"` Event *types.Any `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PublishRequest) Reset() { *m = PublishRequest{} } func (*PublishRequest) ProtoMessage() {} func (*PublishRequest) Descriptor() ([]byte, []int) { return fileDescriptor_43fcd20dc1642376, []int{0} } func (m *PublishRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PublishRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PublishRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PublishRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PublishRequest.Merge(m, src) } func (m *PublishRequest) XXX_Size() int { return m.Size() } func (m *PublishRequest) XXX_DiscardUnknown() { xxx_messageInfo_PublishRequest.DiscardUnknown(m) } var xxx_messageInfo_PublishRequest proto.InternalMessageInfo type ForwardRequest struct { Envelope *Envelope `protobuf:"bytes,1,opt,name=envelope,proto3" json:"envelope,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ForwardRequest) Reset() { *m = ForwardRequest{} } func (*ForwardRequest) ProtoMessage() {} func (*ForwardRequest) Descriptor() ([]byte, []int) { return fileDescriptor_43fcd20dc1642376, []int{1} } func (m *ForwardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ForwardRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ForwardRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ForwardRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ForwardRequest.Merge(m, src) } func (m *ForwardRequest) XXX_Size() int { return m.Size() } func (m *ForwardRequest) XXX_DiscardUnknown() { xxx_messageInfo_ForwardRequest.DiscardUnknown(m) } var xxx_messageInfo_ForwardRequest proto.InternalMessageInfo type SubscribeRequest struct { Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SubscribeRequest) Reset() { *m = SubscribeRequest{} } func (*SubscribeRequest) ProtoMessage() {} func (*SubscribeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_43fcd20dc1642376, []int{2} } func (m *SubscribeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SubscribeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *SubscribeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SubscribeRequest.Merge(m, src) } func (m *SubscribeRequest) XXX_Size() int { return m.Size() } func (m *SubscribeRequest) XXX_DiscardUnknown() { xxx_messageInfo_SubscribeRequest.DiscardUnknown(m) } var xxx_messageInfo_SubscribeRequest proto.InternalMessageInfo type Envelope struct { Timestamp time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp"` Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"` Topic string `protobuf:"bytes,3,opt,name=topic,proto3" json:"topic,omitempty"` Event *types.Any `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Envelope) Reset() { *m = Envelope{} } func (*Envelope) ProtoMessage() {} func (*Envelope) Descriptor() ([]byte, []int) { return fileDescriptor_43fcd20dc1642376, []int{3} } func (m *Envelope) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Envelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Envelope.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Envelope) XXX_Merge(src proto.Message) { xxx_messageInfo_Envelope.Merge(m, src) } func (m *Envelope) XXX_Size() int { return m.Size() } func (m *Envelope) XXX_DiscardUnknown() { xxx_messageInfo_Envelope.DiscardUnknown(m) } var xxx_messageInfo_Envelope proto.InternalMessageInfo func init() { proto.RegisterType((*PublishRequest)(nil), "containerd.services.events.v1.PublishRequest") proto.RegisterType((*ForwardRequest)(nil), "containerd.services.events.v1.ForwardRequest") proto.RegisterType((*SubscribeRequest)(nil), "containerd.services.events.v1.SubscribeRequest") proto.RegisterType((*Envelope)(nil), "containerd.services.events.v1.Envelope") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/events/v1/events.proto", fileDescriptor_43fcd20dc1642376) } var fileDescriptor_43fcd20dc1642376 = []byte{ // 466 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xcd, 0x8e, 0xd3, 0x30, 0x14, 0x85, 0xeb, 0xf9, 0x6d, 0x3c, 0xd2, 0x08, 0x45, 0x15, 0x2a, 0x01, 0xd2, 0xaa, 0x1b, 0x2a, 0x04, 0x0e, 0x53, 0x76, 0x20, 0x21, 0x28, 0x94, 0xf5, 0x28, 0x80, 0x54, 0xb1, 0x4b, 0xd2, 0xdb, 0xd4, 0x52, 0x62, 0x9b, 0xd8, 0x09, 0x9a, 0xdd, 0x3c, 0x02, 0x1b, 0xde, 0x84, 0x0d, 0x6f, 0xd0, 0x25, 0x4b, 0x56, 0xc0, 0xf4, 0x49, 0x50, 0x13, 0xbb, 0x61, 0x3a, 0x40, 0x10, 0xbb, 0x6b, 0xdf, 0xe3, 0xcf, 0xb9, 0xe7, 0x38, 0xf8, 0x45, 0x4c, 0xd5, 0x22, 0x0f, 0x49, 0xc4, 0x53, 0x2f, 0xe2, 0x4c, 0x05, 0x94, 0x41, 0x36, 0xfb, 0xb5, 0x0c, 0x04, 0xf5, 0x24, 0x64, 0x05, 0x8d, 0x40, 0x7a, 0x50, 0x00, 0x53, 0xd2, 0x2b, 0x4e, 0x74, 0x45, 0x44, 0xc6, 0x15, 0xb7, 0x6f, 0xd7, 0x7a, 0x62, 0xb4, 0x44, 0x2b, 0x8a, 0x13, 0xe7, 0x69, 0xe3, 0x25, 0x25, 0x26, 0xcc, 0xe7, 0x9e, 0x48, 0xf2, 0x98, 0x32, 0x6f, 0x4e, 0x21, 0x99, 0x89, 0x40, 0x2d, 0xaa, 0x0b, 0x9c, 0x4e, 0xcc, 0x63, 0x5e, 0x96, 0xde, 0xba, 0xd2, 0xbb, 0x37, 0x62, 0xce, 0xe3, 0x04, 0xea, 0xd3, 0x01, 0x3b, 0xd3, 0xad, 0x9b, 0xdb, 0x2d, 0x48, 0x85, 0x32, 0xcd, 0xde, 0x76, 0x53, 0xd1, 0x14, 0xa4, 0x0a, 0x52, 0x51, 0x09, 0x06, 0x3e, 0x3e, 0x3e, 0xcd, 0xc3, 0x84, 0xca, 0x85, 0x0f, 0xef, 0x72, 0x90, 0xca, 0xee, 0xe0, 0x7d, 0xc5, 0x05, 0x8d, 0xba, 0xa8, 0x8f, 0x86, 0x96, 0x5f, 0x2d, 0xec, 0xbb, 0x78, 0xbf, 0x9c, 0xb2, 0xbb, 0xd3, 0x47, 0xc3, 0xa3, 0x51, 0x87, 0x54, 0x60, 0x62, 0xc0, 0xe4, 0x19, 0x3b, 0xf3, 0x2b, 0xc9, 0xe0, 0x0d, 0x3e, 0x7e, 0xc9, 0xb3, 0xf7, 0x41, 0x36, 0x33, 0xcc, 0xe7, 0xb8, 0x0d, 0xac, 0x80, 0x84, 0x0b, 0x28, 0xb1, 0x47, 0xa3, 0x3b, 0xe4, 0xaf, 0x46, 0x92, 0x89, 0x96, 0xfb, 0x9b, 0x83, 0x83, 0x7b, 0xf8, 0xda, 0xab, 0x3c, 0x94, 0x51, 0x46, 0x43, 0x30, 0xe0, 0x2e, 0x3e, 0x9c, 0xd3, 0x44, 0x41, 0x26, 0xbb, 0xa8, 0xbf, 0x3b, 0xb4, 0x7c, 0xb3, 0x1c, 0x7c, 0x42, 0xb8, 0x6d, 0x20, 0xf6, 0x18, 0x5b, 0x9b, 0xc1, 0xf5, 0x07, 0x38, 0x57, 0x26, 0x78, 0x6d, 0x14, 0xe3, 0xf6, 0xf2, 0x5b, 0xaf, 0xf5, 0xe1, 0x7b, 0x0f, 0xf9, 0xf5, 0x31, 0xfb, 0x16, 0xb6, 0x58, 0x90, 0x82, 0x14, 0x41, 0x04, 0xa5, 0x0b, 0x96, 0x5f, 0x6f, 0xd4, 0xae, 0xed, 0xfe, 0xd6, 0xb5, 0xbd, 0x46, 0xd7, 0x1e, 0xed, 0x9d, 0x7f, 0xee, 0xa1, 0xd1, 0xc7, 0x1d, 0x7c, 0x30, 0x29, 0x5d, 0xb0, 0x4f, 0xf1, 0xa1, 0x8e, 0xc6, 0xbe, 0xdf, 0xe0, 0xd6, 0xe5, 0x08, 0x9d, 0xeb, 0x57, 0xee, 0x99, 0xac, 0xdf, 0xc4, 0x9a, 0xa8, 0x83, 0x69, 0x24, 0x5e, 0x0e, 0xf0, 0x8f, 0xc4, 0x18, 0x5b, 0x9b, 0x4c, 0x6c, 0xaf, 0x81, 0xb9, 0x9d, 0x9e, 0xf3, 0xaf, 0x8f, 0xe0, 0x01, 0x1a, 0x4f, 0x97, 0x17, 0x6e, 0xeb, 0xeb, 0x85, 0xdb, 0x3a, 0x5f, 0xb9, 0x68, 0xb9, 0x72, 0xd1, 0x97, 0x95, 0x8b, 0x7e, 0xac, 0x5c, 0xf4, 0xf6, 0xc9, 0x7f, 0xfe, 0xd7, 0x8f, 0xab, 0x6a, 0xda, 0x9a, 0xa2, 0xf0, 0xa0, 0x1c, 0xeb, 0xe1, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xbf, 0x19, 0xa6, 0x24, 0x04, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *Envelope) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: timestamp case "namespace": return string(m.Namespace), len(m.Namespace) > 0 case "topic": return string(m.Topic), len(m.Topic) > 0 case "event": decoded, err := github_com_containerd_typeurl.UnmarshalAny(m.Event) if err != nil { return "", false } adaptor, ok := decoded.(interface{ Field([]string) (string, bool) }) if !ok { return "", false } return adaptor.Field(fieldpath[1:]) } return "", false } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // EventsClient is the client API for Events service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type EventsClient interface { // Publish an event to a topic. // // The event will be packed into a timestamp envelope with the namespace // introspected from the context. The envelope will then be dispatched. Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*types.Empty, error) // Forward sends an event that has already been packaged into an envelope // with a timestamp and namespace. // // This is useful if earlier timestamping is required or when forwarding on // behalf of another component, namespace or publisher. Forward(ctx context.Context, in *ForwardRequest, opts ...grpc.CallOption) (*types.Empty, error) // Subscribe to a stream of events, possibly returning only that match any // of the provided filters. // // Unlike many other methods in containerd, subscribers will get messages // from all namespaces unless otherwise specified. If this is not desired, // a filter can be provided in the format 'namespace==' to // restrict the received events. Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Events_SubscribeClient, error) } type eventsClient struct { cc *grpc.ClientConn } func NewEventsClient(cc *grpc.ClientConn) EventsClient { return &eventsClient{cc} } func (c *eventsClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.events.v1.Events/Publish", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *eventsClient) Forward(ctx context.Context, in *ForwardRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.events.v1.Events/Forward", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *eventsClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Events_SubscribeClient, error) { stream, err := c.cc.NewStream(ctx, &_Events_serviceDesc.Streams[0], "/containerd.services.events.v1.Events/Subscribe", opts...) if err != nil { return nil, err } x := &eventsSubscribeClient{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 Events_SubscribeClient interface { Recv() (*Envelope, error) grpc.ClientStream } type eventsSubscribeClient struct { grpc.ClientStream } func (x *eventsSubscribeClient) Recv() (*Envelope, error) { m := new(Envelope) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // EventsServer is the server API for Events service. type EventsServer interface { // Publish an event to a topic. // // The event will be packed into a timestamp envelope with the namespace // introspected from the context. The envelope will then be dispatched. Publish(context.Context, *PublishRequest) (*types.Empty, error) // Forward sends an event that has already been packaged into an envelope // with a timestamp and namespace. // // This is useful if earlier timestamping is required or when forwarding on // behalf of another component, namespace or publisher. Forward(context.Context, *ForwardRequest) (*types.Empty, error) // Subscribe to a stream of events, possibly returning only that match any // of the provided filters. // // Unlike many other methods in containerd, subscribers will get messages // from all namespaces unless otherwise specified. If this is not desired, // a filter can be provided in the format 'namespace==' to // restrict the received events. Subscribe(*SubscribeRequest, Events_SubscribeServer) error } // UnimplementedEventsServer can be embedded to have forward compatible implementations. type UnimplementedEventsServer struct { } func (*UnimplementedEventsServer) Publish(ctx context.Context, req *PublishRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Publish not implemented") } func (*UnimplementedEventsServer) Forward(ctx context.Context, req *ForwardRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Forward not implemented") } func (*UnimplementedEventsServer) Subscribe(req *SubscribeRequest, srv Events_SubscribeServer) error { return status.Errorf(codes.Unimplemented, "method Subscribe not implemented") } func RegisterEventsServer(s *grpc.Server, srv EventsServer) { s.RegisterService(&_Events_serviceDesc, srv) } func _Events_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PublishRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(EventsServer).Publish(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.events.v1.Events/Publish", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(EventsServer).Publish(ctx, req.(*PublishRequest)) } return interceptor(ctx, in, info, handler) } func _Events_Forward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ForwardRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(EventsServer).Forward(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.events.v1.Events/Forward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(EventsServer).Forward(ctx, req.(*ForwardRequest)) } return interceptor(ctx, in, info, handler) } func _Events_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SubscribeRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(EventsServer).Subscribe(m, &eventsSubscribeServer{stream}) } type Events_SubscribeServer interface { Send(*Envelope) error grpc.ServerStream } type eventsSubscribeServer struct { grpc.ServerStream } func (x *eventsSubscribeServer) Send(m *Envelope) error { return x.ServerStream.SendMsg(m) } var _Events_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.events.v1.Events", HandlerType: (*EventsServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Publish", Handler: _Events_Publish_Handler, }, { MethodName: "Forward", Handler: _Events_Forward_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "Subscribe", Handler: _Events_Subscribe_Handler, ServerStreams: true, }, }, Metadata: "github.com/containerd/containerd/api/services/events/v1/events.proto", } func (m *PublishRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PublishRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PublishRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Event != nil { { size, err := m.Event.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Topic) > 0 { i -= len(m.Topic) copy(dAtA[i:], m.Topic) i = encodeVarintEvents(dAtA, i, uint64(len(m.Topic))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ForwardRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ForwardRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ForwardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Envelope != nil { { size, err := m.Envelope.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SubscribeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SubscribeRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintEvents(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *Envelope) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Envelope) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Envelope) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Event != nil { { size, err := m.Event.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.Topic) > 0 { i -= len(m.Topic) copy(dAtA[i:], m.Topic) i = encodeVarintEvents(dAtA, i, uint64(len(m.Topic))) i-- dAtA[i] = 0x1a } if len(m.Namespace) > 0 { i -= len(m.Namespace) copy(dAtA[i:], m.Namespace) i = encodeVarintEvents(dAtA, i, uint64(len(m.Namespace))) i-- dAtA[i] = 0x12 } n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):]) if err4 != nil { return 0, err4 } i -= n4 i = encodeVarintEvents(dAtA, i, uint64(n4)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { offset -= sovEvents(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *PublishRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Topic) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } if m.Event != nil { l = m.Event.Size() n += 1 + l + sovEvents(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ForwardRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Envelope != nil { l = m.Envelope.Size() n += 1 + l + sovEvents(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SubscribeRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovEvents(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Envelope) Size() (n int) { if m == nil { return 0 } var l int _ = l l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp) n += 1 + l + sovEvents(uint64(l)) l = len(m.Namespace) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } l = len(m.Topic) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } if m.Event != nil { l = m.Event.Size() n += 1 + l + sovEvents(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovEvents(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozEvents(x uint64) (n int) { return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *PublishRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PublishRequest{`, `Topic:` + fmt.Sprintf("%v", this.Topic) + `,`, `Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ForwardRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ForwardRequest{`, `Envelope:` + strings.Replace(this.Envelope.String(), "Envelope", "Envelope", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *SubscribeRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SubscribeRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Envelope) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Envelope{`, `Timestamp:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, `Topic:` + fmt.Sprintf("%v", this.Topic) + `,`, `Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringEvents(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *PublishRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PublishRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PublishRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Topic = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if m.Event == nil { m.Event = &types.Any{} } if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ForwardRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ForwardRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ForwardRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Envelope", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if m.Envelope == nil { m.Envelope = &Envelope{} } if err := m.Envelope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *SubscribeRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: SubscribeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SubscribeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Envelope) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Envelope: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Envelope: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Namespace = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Topic = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if m.Event == nil { m.Event = &types.Any{} } if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipEvents(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthEvents } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupEvents } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthEvents } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthEvents = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowEvents = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/events/v1/events.proto000066400000000000000000000045261416535272200225110ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.events.v1; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; import weak "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/services/events/v1;events"; service Events { // Publish an event to a topic. // // The event will be packed into a timestamp envelope with the namespace // introspected from the context. The envelope will then be dispatched. rpc Publish(PublishRequest) returns (google.protobuf.Empty); // Forward sends an event that has already been packaged into an envelope // with a timestamp and namespace. // // This is useful if earlier timestamping is required or when forwarding on // behalf of another component, namespace or publisher. rpc Forward(ForwardRequest) returns (google.protobuf.Empty); // Subscribe to a stream of events, possibly returning only that match any // of the provided filters. // // Unlike many other methods in containerd, subscribers will get messages // from all namespaces unless otherwise specified. If this is not desired, // a filter can be provided in the format 'namespace==' to // restrict the received events. rpc Subscribe(SubscribeRequest) returns (stream Envelope); } message PublishRequest { string topic = 1; google.protobuf.Any event = 2; } message ForwardRequest { Envelope envelope = 1; } message SubscribeRequest { repeated string filters = 1; } message Envelope { option (containerd.plugin.fieldpath) = true; google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; string namespace = 2; string topic = 3; google.protobuf.Any event = 4; } containerd-1.5.9/api/services/images/000077500000000000000000000000001416535272200175245ustar00rootroot00000000000000containerd-1.5.9/api/services/images/v1/000077500000000000000000000000001416535272200200525ustar00rootroot00000000000000containerd-1.5.9/api/services/images/v1/docs.go000066400000000000000000000011431416535272200213300ustar00rootroot00000000000000/* Copyright The containerd 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 images containerd-1.5.9/api/services/images/v1/images.pb.go000066400000000000000000002173421416535272200222570ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/images/v1/images.proto package images import ( context "context" fmt "fmt" types "github.com/containerd/containerd/api/types" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Image struct { // Name provides a unique name for the image. // // Containerd treats this as the primary identifier. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Labels provides free form labels for the image. These are runtime only // and do not get inherited into the package image in any way. // // Labels may be updated using the field mask. // The combined size of a key/value pair cannot exceed 4096 bytes. 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"` // Target describes the content entry point of the image. Target types.Descriptor `protobuf:"bytes,3,opt,name=target,proto3" json:"target"` // CreatedAt is the time the image was first created. CreatedAt time.Time `protobuf:"bytes,7,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` // UpdatedAt is the last time the image was mutated. UpdatedAt time.Time `protobuf:"bytes,8,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Image) Reset() { *m = Image{} } func (*Image) ProtoMessage() {} func (*Image) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{0} } func (m *Image) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Image.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Image) XXX_Merge(src proto.Message) { xxx_messageInfo_Image.Merge(m, src) } func (m *Image) XXX_Size() int { return m.Size() } func (m *Image) XXX_DiscardUnknown() { xxx_messageInfo_Image.DiscardUnknown(m) } var xxx_messageInfo_Image proto.InternalMessageInfo type GetImageRequest struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetImageRequest) Reset() { *m = GetImageRequest{} } func (*GetImageRequest) ProtoMessage() {} func (*GetImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{1} } func (m *GetImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetImageRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetImageRequest.Merge(m, src) } func (m *GetImageRequest) XXX_Size() int { return m.Size() } func (m *GetImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetImageRequest.DiscardUnknown(m) } var xxx_messageInfo_GetImageRequest proto.InternalMessageInfo type GetImageResponse struct { Image *Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetImageResponse) Reset() { *m = GetImageResponse{} } func (*GetImageResponse) ProtoMessage() {} func (*GetImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{2} } func (m *GetImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetImageResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetImageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetImageResponse.Merge(m, src) } func (m *GetImageResponse) XXX_Size() int { return m.Size() } func (m *GetImageResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetImageResponse.DiscardUnknown(m) } var xxx_messageInfo_GetImageResponse proto.InternalMessageInfo type CreateImageRequest struct { Image Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateImageRequest) Reset() { *m = CreateImageRequest{} } func (*CreateImageRequest) ProtoMessage() {} func (*CreateImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{3} } func (m *CreateImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateImageRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateImageRequest.Merge(m, src) } func (m *CreateImageRequest) XXX_Size() int { return m.Size() } func (m *CreateImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateImageRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateImageRequest proto.InternalMessageInfo type CreateImageResponse struct { Image Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateImageResponse) Reset() { *m = CreateImageResponse{} } func (*CreateImageResponse) ProtoMessage() {} func (*CreateImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{4} } func (m *CreateImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateImageResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateImageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateImageResponse.Merge(m, src) } func (m *CreateImageResponse) XXX_Size() int { return m.Size() } func (m *CreateImageResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateImageResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateImageResponse proto.InternalMessageInfo type UpdateImageRequest struct { // Image provides a full or partial image for update. // // The name field must be set or an error will be returned. Image Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image"` // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. UpdateMask *types1.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateImageRequest) Reset() { *m = UpdateImageRequest{} } func (*UpdateImageRequest) ProtoMessage() {} func (*UpdateImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{5} } func (m *UpdateImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateImageRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateImageRequest.Merge(m, src) } func (m *UpdateImageRequest) XXX_Size() int { return m.Size() } func (m *UpdateImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateImageRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateImageRequest proto.InternalMessageInfo type UpdateImageResponse struct { Image Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateImageResponse) Reset() { *m = UpdateImageResponse{} } func (*UpdateImageResponse) ProtoMessage() {} func (*UpdateImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{6} } func (m *UpdateImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateImageResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateImageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateImageResponse.Merge(m, src) } func (m *UpdateImageResponse) XXX_Size() int { return m.Size() } func (m *UpdateImageResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateImageResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateImageResponse proto.InternalMessageInfo type ListImagesRequest struct { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, images that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListImagesRequest) Reset() { *m = ListImagesRequest{} } func (*ListImagesRequest) ProtoMessage() {} func (*ListImagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{7} } func (m *ListImagesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListImagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListImagesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListImagesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListImagesRequest.Merge(m, src) } func (m *ListImagesRequest) XXX_Size() int { return m.Size() } func (m *ListImagesRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListImagesRequest.DiscardUnknown(m) } var xxx_messageInfo_ListImagesRequest proto.InternalMessageInfo type ListImagesResponse struct { Images []Image `protobuf:"bytes,1,rep,name=images,proto3" json:"images"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListImagesResponse) Reset() { *m = ListImagesResponse{} } func (*ListImagesResponse) ProtoMessage() {} func (*ListImagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{8} } func (m *ListImagesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListImagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListImagesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListImagesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListImagesResponse.Merge(m, src) } func (m *ListImagesResponse) XXX_Size() int { return m.Size() } func (m *ListImagesResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListImagesResponse.DiscardUnknown(m) } var xxx_messageInfo_ListImagesResponse proto.InternalMessageInfo type DeleteImageRequest struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Sync indicates that the delete and cleanup should be done // synchronously before returning to the caller // // Default is false Sync bool `protobuf:"varint,2,opt,name=sync,proto3" json:"sync,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteImageRequest) Reset() { *m = DeleteImageRequest{} } func (*DeleteImageRequest) ProtoMessage() {} func (*DeleteImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8666fa071128ae5f, []int{9} } func (m *DeleteImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteImageRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteImageRequest.Merge(m, src) } func (m *DeleteImageRequest) XXX_Size() int { return m.Size() } func (m *DeleteImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteImageRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteImageRequest proto.InternalMessageInfo func init() { proto.RegisterType((*Image)(nil), "containerd.services.images.v1.Image") proto.RegisterMapType((map[string]string)(nil), "containerd.services.images.v1.Image.LabelsEntry") proto.RegisterType((*GetImageRequest)(nil), "containerd.services.images.v1.GetImageRequest") proto.RegisterType((*GetImageResponse)(nil), "containerd.services.images.v1.GetImageResponse") proto.RegisterType((*CreateImageRequest)(nil), "containerd.services.images.v1.CreateImageRequest") proto.RegisterType((*CreateImageResponse)(nil), "containerd.services.images.v1.CreateImageResponse") proto.RegisterType((*UpdateImageRequest)(nil), "containerd.services.images.v1.UpdateImageRequest") proto.RegisterType((*UpdateImageResponse)(nil), "containerd.services.images.v1.UpdateImageResponse") proto.RegisterType((*ListImagesRequest)(nil), "containerd.services.images.v1.ListImagesRequest") proto.RegisterType((*ListImagesResponse)(nil), "containerd.services.images.v1.ListImagesResponse") proto.RegisterType((*DeleteImageRequest)(nil), "containerd.services.images.v1.DeleteImageRequest") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/images/v1/images.proto", fileDescriptor_8666fa071128ae5f) } var fileDescriptor_8666fa071128ae5f = []byte{ // 659 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x40, 0x10, 0x8e, 0x93, 0xd4, 0x6d, 0x27, 0x07, 0xca, 0x52, 0x21, 0xcb, 0x40, 0x1a, 0x45, 0x20, 0xe5, 0xc2, 0x9a, 0x86, 0x0b, 0xb4, 0x08, 0xd1, 0xb4, 0xa5, 0x20, 0x15, 0x0e, 0xe6, 0xaf, 0xe2, 0x52, 0x6d, 0x92, 0x89, 0xb1, 0x62, 0xc7, 0xc6, 0xbb, 0x89, 0x94, 0x1b, 0x8f, 0x80, 0x04, 0x0f, 0xd5, 0x23, 0x47, 0x4e, 0x40, 0x73, 0xe0, 0x39, 0x90, 0x77, 0x37, 0x34, 0x4d, 0x22, 0x92, 0x94, 0xde, 0x66, 0xed, 0xef, 0x9b, 0x9f, 0x6f, 0x66, 0x76, 0x61, 0xcf, 0xf3, 0xc5, 0x87, 0x6e, 0x9d, 0x36, 0xa2, 0xd0, 0x69, 0x44, 0x1d, 0xc1, 0xfc, 0x0e, 0x26, 0xcd, 0x51, 0x93, 0xc5, 0xbe, 0xc3, 0x31, 0xe9, 0xf9, 0x0d, 0xe4, 0x8e, 0x1f, 0x32, 0x0f, 0xb9, 0xd3, 0xdb, 0xd4, 0x16, 0x8d, 0x93, 0x48, 0x44, 0xe4, 0xd6, 0x19, 0x9e, 0x0e, 0xb1, 0x54, 0x23, 0x7a, 0x9b, 0xf6, 0xba, 0x17, 0x79, 0x91, 0x44, 0x3a, 0xa9, 0xa5, 0x48, 0xf6, 0x0d, 0x2f, 0x8a, 0xbc, 0x00, 0x1d, 0x79, 0xaa, 0x77, 0x5b, 0x0e, 0x86, 0xb1, 0xe8, 0xeb, 0x9f, 0xa5, 0xf1, 0x9f, 0x2d, 0x1f, 0x83, 0xe6, 0x71, 0xc8, 0x78, 0x5b, 0x23, 0x36, 0xc6, 0x11, 0xc2, 0x0f, 0x91, 0x0b, 0x16, 0xc6, 0x1a, 0xb0, 0x3d, 0x57, 0x69, 0xa2, 0x1f, 0x23, 0x77, 0x9a, 0xc8, 0x1b, 0x89, 0x1f, 0x8b, 0x28, 0x51, 0xe4, 0xf2, 0xef, 0x2c, 0x2c, 0x3d, 0x4f, 0x0b, 0x20, 0x04, 0xf2, 0x1d, 0x16, 0xa2, 0x65, 0x94, 0x8c, 0xca, 0xaa, 0x2b, 0x6d, 0xf2, 0x0c, 0xcc, 0x80, 0xd5, 0x31, 0xe0, 0x56, 0xb6, 0x94, 0xab, 0x14, 0xaa, 0xf7, 0xe8, 0x3f, 0x05, 0xa0, 0xd2, 0x13, 0x3d, 0x94, 0x94, 0xfd, 0x8e, 0x48, 0xfa, 0xae, 0xe6, 0x93, 0x2d, 0x30, 0x05, 0x4b, 0x3c, 0x14, 0x56, 0xae, 0x64, 0x54, 0x0a, 0xd5, 0x9b, 0xa3, 0x9e, 0x64, 0x6e, 0x74, 0xef, 0x6f, 0x6e, 0xb5, 0xfc, 0xc9, 0x8f, 0x8d, 0x8c, 0xab, 0x19, 0x64, 0x17, 0xa0, 0x91, 0x20, 0x13, 0xd8, 0x3c, 0x66, 0xc2, 0x5a, 0x96, 0x7c, 0x9b, 0x2a, 0x59, 0xe8, 0x50, 0x16, 0xfa, 0x7a, 0x28, 0x4b, 0x6d, 0x25, 0x65, 0x7f, 0xfe, 0xb9, 0x61, 0xb8, 0xab, 0x9a, 0xb7, 0x23, 0x9d, 0x74, 0xe3, 0xe6, 0xd0, 0xc9, 0xca, 0x22, 0x4e, 0x34, 0x6f, 0x47, 0xd8, 0x0f, 0xa1, 0x30, 0x52, 0x1c, 0x59, 0x83, 0x5c, 0x1b, 0xfb, 0x5a, 0xb1, 0xd4, 0x24, 0xeb, 0xb0, 0xd4, 0x63, 0x41, 0x17, 0xad, 0xac, 0xfc, 0xa6, 0x0e, 0x5b, 0xd9, 0x07, 0x46, 0xf9, 0x0e, 0x5c, 0x39, 0x40, 0x21, 0x05, 0x72, 0xf1, 0x63, 0x17, 0xb9, 0x98, 0xa6, 0x78, 0xf9, 0x25, 0xac, 0x9d, 0xc1, 0x78, 0x1c, 0x75, 0x38, 0x92, 0x2d, 0x58, 0x92, 0x12, 0x4b, 0x60, 0xa1, 0x7a, 0x7b, 0x9e, 0x26, 0xb8, 0x8a, 0x52, 0x7e, 0x0b, 0x64, 0x57, 0x6a, 0x70, 0x2e, 0xf2, 0x93, 0x0b, 0x78, 0xd4, 0x4d, 0xd1, 0x7e, 0xdf, 0xc1, 0xb5, 0x73, 0x7e, 0x75, 0xaa, 0xff, 0xef, 0xf8, 0x8b, 0x01, 0xe4, 0x8d, 0x14, 0xfc, 0x72, 0x33, 0x26, 0xdb, 0x50, 0x50, 0x8d, 0x94, 0xcb, 0x25, 0x1b, 0x34, 0x6d, 0x02, 0x9e, 0xa6, 0xfb, 0xf7, 0x82, 0xf1, 0xb6, 0xab, 0xe7, 0x25, 0xb5, 0xd3, 0x72, 0xcf, 0x25, 0x75, 0x69, 0xe5, 0xde, 0x85, 0xab, 0x87, 0x3e, 0x57, 0x0d, 0xe7, 0xc3, 0x62, 0x2d, 0x58, 0x6e, 0xf9, 0x81, 0xc0, 0x84, 0x5b, 0x46, 0x29, 0x57, 0x59, 0x75, 0x87, 0xc7, 0xf2, 0x11, 0x90, 0x51, 0xb8, 0x4e, 0xa3, 0x06, 0xa6, 0x0a, 0x22, 0xe1, 0x8b, 0xe5, 0xa1, 0x99, 0xe5, 0x47, 0x40, 0xf6, 0x30, 0xc0, 0x31, 0xd9, 0xa7, 0x5d, 0x0a, 0x04, 0xf2, 0xbc, 0xdf, 0x69, 0x48, 0x05, 0x57, 0x5c, 0x69, 0x57, 0xbf, 0xe6, 0xc1, 0x54, 0x49, 0x91, 0x16, 0xe4, 0x0e, 0x50, 0x10, 0x3a, 0x23, 0x87, 0xb1, 0x65, 0xb0, 0x9d, 0xb9, 0xf1, 0xba, 0xe8, 0x36, 0xe4, 0x53, 0x29, 0xc8, 0xac, 0x3b, 0x69, 0x42, 0x5e, 0x7b, 0x73, 0x01, 0x86, 0x0e, 0x16, 0x81, 0xa9, 0xc6, 0x9d, 0xcc, 0x22, 0x4f, 0x6e, 0x9b, 0x5d, 0x5d, 0x84, 0x72, 0x16, 0x50, 0x0d, 0xdc, 0xcc, 0x80, 0x93, 0xcb, 0x32, 0x33, 0xe0, 0xb4, 0x51, 0x7e, 0x05, 0xa6, 0xea, 0xff, 0xcc, 0x80, 0x93, 0x63, 0x62, 0x5f, 0x9f, 0x58, 0xa3, 0xfd, 0xf4, 0x8d, 0xab, 0x1d, 0x9d, 0x9c, 0x16, 0x33, 0xdf, 0x4f, 0x8b, 0x99, 0x4f, 0x83, 0xa2, 0x71, 0x32, 0x28, 0x1a, 0xdf, 0x06, 0x45, 0xe3, 0xd7, 0xa0, 0x68, 0xbc, 0x7f, 0x7c, 0xc1, 0xf7, 0x78, 0x5b, 0x59, 0x47, 0x99, 0xba, 0x29, 0x63, 0xdd, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x24, 0x4e, 0xca, 0x64, 0xda, 0x07, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // ImagesClient is the client API for Images service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ImagesClient interface { // Get returns an image by name. Get(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*GetImageResponse, error) // List returns a list of all images known to containerd. List(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) // Create an image record in the metadata store. // // The name of the image must be unique. Create(ctx context.Context, in *CreateImageRequest, opts ...grpc.CallOption) (*CreateImageResponse, error) // Update assigns the name to a given target image based on the provided // image. Update(ctx context.Context, in *UpdateImageRequest, opts ...grpc.CallOption) (*UpdateImageResponse, error) // Delete deletes the image by name. Delete(ctx context.Context, in *DeleteImageRequest, opts ...grpc.CallOption) (*types1.Empty, error) } type imagesClient struct { cc *grpc.ClientConn } func NewImagesClient(cc *grpc.ClientConn) ImagesClient { return &imagesClient{cc} } func (c *imagesClient) Get(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*GetImageResponse, error) { out := new(GetImageResponse) err := c.cc.Invoke(ctx, "/containerd.services.images.v1.Images/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imagesClient) List(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) { out := new(ListImagesResponse) err := c.cc.Invoke(ctx, "/containerd.services.images.v1.Images/List", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imagesClient) Create(ctx context.Context, in *CreateImageRequest, opts ...grpc.CallOption) (*CreateImageResponse, error) { out := new(CreateImageResponse) err := c.cc.Invoke(ctx, "/containerd.services.images.v1.Images/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imagesClient) Update(ctx context.Context, in *UpdateImageRequest, opts ...grpc.CallOption) (*UpdateImageResponse, error) { out := new(UpdateImageResponse) err := c.cc.Invoke(ctx, "/containerd.services.images.v1.Images/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imagesClient) Delete(ctx context.Context, in *DeleteImageRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.images.v1.Images/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } // ImagesServer is the server API for Images service. type ImagesServer interface { // Get returns an image by name. Get(context.Context, *GetImageRequest) (*GetImageResponse, error) // List returns a list of all images known to containerd. List(context.Context, *ListImagesRequest) (*ListImagesResponse, error) // Create an image record in the metadata store. // // The name of the image must be unique. Create(context.Context, *CreateImageRequest) (*CreateImageResponse, error) // Update assigns the name to a given target image based on the provided // image. Update(context.Context, *UpdateImageRequest) (*UpdateImageResponse, error) // Delete deletes the image by name. Delete(context.Context, *DeleteImageRequest) (*types1.Empty, error) } // UnimplementedImagesServer can be embedded to have forward compatible implementations. type UnimplementedImagesServer struct { } func (*UnimplementedImagesServer) Get(ctx context.Context, req *GetImageRequest) (*GetImageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") } func (*UnimplementedImagesServer) List(ctx context.Context, req *ListImagesRequest) (*ListImagesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedImagesServer) Create(ctx context.Context, req *CreateImageRequest) (*CreateImageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") } func (*UnimplementedImagesServer) Update(ctx context.Context, req *UpdateImageRequest) (*UpdateImageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedImagesServer) Delete(ctx context.Context, req *DeleteImageRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func RegisterImagesServer(s *grpc.Server, srv ImagesServer) { s.RegisterService(&_Images_serviceDesc, srv) } func _Images_Get_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.(ImagesServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.images.v1.Images/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImagesServer).Get(ctx, req.(*GetImageRequest)) } return interceptor(ctx, in, info, handler) } func _Images_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListImagesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImagesServer).List(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.images.v1.Images/List", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImagesServer).List(ctx, req.(*ListImagesRequest)) } return interceptor(ctx, in, info, handler) } func _Images_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateImageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImagesServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.images.v1.Images/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImagesServer).Create(ctx, req.(*CreateImageRequest)) } return interceptor(ctx, in, info, handler) } func _Images_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateImageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImagesServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.images.v1.Images/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImagesServer).Update(ctx, req.(*UpdateImageRequest)) } return interceptor(ctx, in, info, handler) } func _Images_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteImageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImagesServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.images.v1.Images/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImagesServer).Delete(ctx, req.(*DeleteImageRequest)) } return interceptor(ctx, in, info, handler) } var _Images_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.images.v1.Images", HandlerType: (*ImagesServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Get", Handler: _Images_Get_Handler, }, { MethodName: "List", Handler: _Images_List_Handler, }, { MethodName: "Create", Handler: _Images_Create_Handler, }, { MethodName: "Update", Handler: _Images_Update_Handler, }, { MethodName: "Delete", Handler: _Images_Delete_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/images/v1/images.proto", } func (m *Image) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Image) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Image) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err1 != nil { return 0, err1 } i -= n1 i = encodeVarintImages(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x42 n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintImages(dAtA, i, uint64(n2)) i-- dAtA[i] = 0x3a { size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintImages(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintImages(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintImages(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImages(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetImageRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImages(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetImageResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetImageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetImageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Image != nil { { size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CreateImageRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *CreateImageResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateImageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateImageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateImageRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.UpdateMask != nil { { size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } { size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateImageResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateImageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateImageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *ListImagesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListImagesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListImagesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintImages(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ListImagesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListImagesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListImagesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Images) > 0 { for iNdEx := len(m.Images) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Images[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintImages(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *DeleteImageRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Sync { i-- if m.Sync { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintImages(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintImages(dAtA []byte, offset int, v uint64) int { offset -= sovImages(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Image) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImages(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovImages(uint64(len(k))) + 1 + len(v) + sovImages(uint64(len(v))) n += mapEntrySize + 1 + sovImages(uint64(mapEntrySize)) } } l = m.Target.Size() n += 1 + l + sovImages(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) n += 1 + l + sovImages(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovImages(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImages(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetImageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovImages(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Image.Size() n += 1 + l + sovImages(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateImageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Image.Size() n += 1 + l + sovImages(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Image.Size() n += 1 + l + sovImages(uint64(l)) if m.UpdateMask != nil { l = m.UpdateMask.Size() n += 1 + l + sovImages(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateImageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Image.Size() n += 1 + l + sovImages(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListImagesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovImages(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListImagesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Images) > 0 { for _, e := range m.Images { l = e.Size() n += 1 + l + sovImages(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovImages(uint64(l)) } if m.Sync { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovImages(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozImages(x uint64) (n int) { return sovImages(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Image) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&Image{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `Target:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Target), "Descriptor", "types.Descriptor", 1), `&`, ``, 1) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetImageRequest{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetImageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetImageResponse{`, `Image:` + strings.Replace(this.Image.String(), "Image", "Image", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateImageRequest{`, `Image:` + strings.Replace(strings.Replace(this.Image.String(), "Image", "Image", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateImageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateImageResponse{`, `Image:` + strings.Replace(strings.Replace(this.Image.String(), "Image", "Image", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateImageRequest{`, `Image:` + strings.Replace(strings.Replace(this.Image.String(), "Image", "Image", 1), `&`, ``, 1) + `,`, `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types1.FieldMask", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateImageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateImageResponse{`, `Image:` + strings.Replace(strings.Replace(this.Image.String(), "Image", "Image", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListImagesRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListImagesRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListImagesResponse) String() string { if this == nil { return "nil" } repeatedStringForImages := "[]Image{" for _, f := range this.Images { repeatedStringForImages += strings.Replace(strings.Replace(f.String(), "Image", "Image", 1), `&`, ``, 1) + "," } repeatedStringForImages += "}" s := strings.Join([]string{`&ListImagesResponse{`, `Images:` + repeatedStringForImages + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteImageRequest{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Sync:` + fmt.Sprintf("%v", this.Sync) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringImages(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Image) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Image: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthImages } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthImages } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthImages } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthImages } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetImageRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetImageRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetImageResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetImageResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if m.Image == nil { m.Image = &Image{} } if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateImageRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateImageRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateImageResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateImageResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateImageRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateImageRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if m.UpdateMask == nil { m.UpdateMask = &types1.FieldMask{} } if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateImageResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateImageResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListImagesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListImagesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListImagesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListImagesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListImagesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListImagesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Images", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } m.Images = append(m.Images, Image{}) if err := m.Images[len(m.Images)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteImageRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteImageRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthImages } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthImages } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Sync", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImages } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Sync = bool(v != 0) default: iNdEx = preIndex skippy, err := skipImages(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthImages } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipImages(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImages } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImages } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImages } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthImages } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupImages } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthImages } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthImages = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowImages = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupImages = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/images/v1/images.proto000066400000000000000000000105431416535272200224070ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.images.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/field_mask.proto"; import "google/protobuf/timestamp.proto"; import "github.com/containerd/containerd/api/types/descriptor.proto"; option go_package = "github.com/containerd/containerd/api/services/images/v1;images"; // Images is a service that allows one to register images with containerd. // // In containerd, an image is merely the mapping of a name to a content root, // described by a descriptor. The behavior and state of image is purely // dictated by the type of the descriptor. // // From the perspective of this service, these references are mostly shallow, // in that the existence of the required content won't be validated until // required by consuming services. // // As such, this can really be considered a "metadata service". service Images { // Get returns an image by name. rpc Get(GetImageRequest) returns (GetImageResponse); // List returns a list of all images known to containerd. rpc List(ListImagesRequest) returns (ListImagesResponse); // Create an image record in the metadata store. // // The name of the image must be unique. rpc Create(CreateImageRequest) returns (CreateImageResponse); // Update assigns the name to a given target image based on the provided // image. rpc Update(UpdateImageRequest) returns (UpdateImageResponse); // Delete deletes the image by name. rpc Delete(DeleteImageRequest) returns (google.protobuf.Empty); } message Image { // Name provides a unique name for the image. // // Containerd treats this as the primary identifier. string name = 1; // Labels provides free form labels for the image. These are runtime only // and do not get inherited into the package image in any way. // // Labels may be updated using the field mask. // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 2; // Target describes the content entry point of the image. containerd.types.Descriptor target = 3 [(gogoproto.nullable) = false]; // CreatedAt is the time the image was first created. google.protobuf.Timestamp created_at = 7 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // UpdatedAt is the last time the image was mutated. google.protobuf.Timestamp updated_at = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; } message GetImageRequest { string name = 1; } message GetImageResponse { Image image = 1; } message CreateImageRequest { Image image = 1 [(gogoproto.nullable) = false]; } message CreateImageResponse { Image image = 1 [(gogoproto.nullable) = false]; } message UpdateImageRequest { // Image provides a full or partial image for update. // // The name field must be set or an error will be returned. Image image = 1 [(gogoproto.nullable) = false]; // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. google.protobuf.FieldMask update_mask = 2; } message UpdateImageResponse { Image image = 1 [(gogoproto.nullable) = false]; } message ListImagesRequest { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, images that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. repeated string filters = 1; } message ListImagesResponse { repeated Image images = 1 [(gogoproto.nullable) = false]; } message DeleteImageRequest { string name = 1; // Sync indicates that the delete and cleanup should be done // synchronously before returning to the caller // // Default is false bool sync = 2; } containerd-1.5.9/api/services/introspection/000077500000000000000000000000001416535272200211575ustar00rootroot00000000000000containerd-1.5.9/api/services/introspection/v1/000077500000000000000000000000001416535272200215055ustar00rootroot00000000000000containerd-1.5.9/api/services/introspection/v1/doc.go000066400000000000000000000011521416535272200226000ustar00rootroot00000000000000/* Copyright The containerd 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 introspection containerd-1.5.9/api/services/introspection/v1/introspection.pb.go000066400000000000000000001236261416535272200253460ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/introspection/v1/introspection.proto package introspection import ( context "context" fmt "fmt" types "github.com/containerd/containerd/api/types" rpc "github.com/gogo/googleapis/google/rpc" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" types1 "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Plugin struct { // Type defines the type of plugin. // // See package plugin for a list of possible values. Non core plugins may // define their own values during registration. Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` // ID identifies the plugin uniquely in the system. ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` // Requires lists the plugin types required by this plugin. Requires []string `protobuf:"bytes,3,rep,name=requires,proto3" json:"requires,omitempty"` // Platforms enumerates the platforms this plugin will support. // // If values are provided here, the plugin will only be operable under the // provided platforms. // // If this is empty, the plugin will work across all platforms. // // If the plugin prefers certain platforms over others, they should be // listed from most to least preferred. Platforms []types.Platform `protobuf:"bytes,4,rep,name=platforms,proto3" json:"platforms"` // Exports allows plugins to provide values about state or configuration to // interested parties. // // One example is exposing the configured path of a snapshotter plugin. Exports map[string]string `protobuf:"bytes,5,rep,name=exports,proto3" json:"exports,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Capabilities allows plugins to communicate feature switches to allow // clients to detect features that may not be on be default or may be // different from version to version. // // Use this sparingly. Capabilities []string `protobuf:"bytes,6,rep,name=capabilities,proto3" json:"capabilities,omitempty"` // InitErr will be set if the plugin fails initialization. // // This means the plugin may have been registered but a non-terminal error // was encountered during initialization. // // Plugins that have this value set cannot be used. InitErr *rpc.Status `protobuf:"bytes,7,opt,name=init_err,json=initErr,proto3" json:"init_err,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Plugin) Reset() { *m = Plugin{} } func (*Plugin) ProtoMessage() {} func (*Plugin) Descriptor() ([]byte, []int) { return fileDescriptor_1a14fda866f10715, []int{0} } func (m *Plugin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Plugin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Plugin.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Plugin) XXX_Merge(src proto.Message) { xxx_messageInfo_Plugin.Merge(m, src) } func (m *Plugin) XXX_Size() int { return m.Size() } func (m *Plugin) XXX_DiscardUnknown() { xxx_messageInfo_Plugin.DiscardUnknown(m) } var xxx_messageInfo_Plugin proto.InternalMessageInfo type PluginsRequest struct { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, plugins that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PluginsRequest) Reset() { *m = PluginsRequest{} } func (*PluginsRequest) ProtoMessage() {} func (*PluginsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_1a14fda866f10715, []int{1} } func (m *PluginsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PluginsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PluginsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PluginsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PluginsRequest.Merge(m, src) } func (m *PluginsRequest) XXX_Size() int { return m.Size() } func (m *PluginsRequest) XXX_DiscardUnknown() { xxx_messageInfo_PluginsRequest.DiscardUnknown(m) } var xxx_messageInfo_PluginsRequest proto.InternalMessageInfo type PluginsResponse struct { Plugins []Plugin `protobuf:"bytes,1,rep,name=plugins,proto3" json:"plugins"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PluginsResponse) Reset() { *m = PluginsResponse{} } func (*PluginsResponse) ProtoMessage() {} func (*PluginsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_1a14fda866f10715, []int{2} } func (m *PluginsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PluginsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PluginsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PluginsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PluginsResponse.Merge(m, src) } func (m *PluginsResponse) XXX_Size() int { return m.Size() } func (m *PluginsResponse) XXX_DiscardUnknown() { xxx_messageInfo_PluginsResponse.DiscardUnknown(m) } var xxx_messageInfo_PluginsResponse proto.InternalMessageInfo type ServerResponse struct { UUID string `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerResponse) Reset() { *m = ServerResponse{} } func (*ServerResponse) ProtoMessage() {} func (*ServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_1a14fda866f10715, []int{3} } func (m *ServerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ServerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerResponse.Merge(m, src) } func (m *ServerResponse) XXX_Size() int { return m.Size() } func (m *ServerResponse) XXX_DiscardUnknown() { xxx_messageInfo_ServerResponse.DiscardUnknown(m) } var xxx_messageInfo_ServerResponse proto.InternalMessageInfo func init() { proto.RegisterType((*Plugin)(nil), "containerd.services.introspection.v1.Plugin") proto.RegisterMapType((map[string]string)(nil), "containerd.services.introspection.v1.Plugin.ExportsEntry") proto.RegisterType((*PluginsRequest)(nil), "containerd.services.introspection.v1.PluginsRequest") proto.RegisterType((*PluginsResponse)(nil), "containerd.services.introspection.v1.PluginsResponse") proto.RegisterType((*ServerResponse)(nil), "containerd.services.introspection.v1.ServerResponse") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/introspection/v1/introspection.proto", fileDescriptor_1a14fda866f10715) } var fileDescriptor_1a14fda866f10715 = []byte{ // 549 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xc1, 0x6e, 0xd3, 0x40, 0x10, 0xad, 0x9d, 0x34, 0x6e, 0x37, 0xa5, 0xa0, 0x55, 0x55, 0x2c, 0x83, 0x9c, 0x28, 0xe2, 0x10, 0x21, 0x58, 0xab, 0x01, 0x24, 0x5a, 0x24, 0x0e, 0x51, 0x73, 0x88, 0xd4, 0x43, 0xe5, 0xa8, 0x08, 0x71, 0xa9, 0x1c, 0x67, 0x63, 0x56, 0x38, 0xde, 0xed, 0xee, 0xda, 0x22, 0x37, 0x3e, 0x2f, 0x47, 0x8e, 0x9c, 0x02, 0xf5, 0x37, 0xf0, 0x01, 0xc8, 0xbb, 0x76, 0x9a, 0xdc, 0x12, 0x71, 0x9b, 0x79, 0x33, 0x6f, 0xe6, 0xcd, 0xf3, 0xca, 0xc0, 0x8f, 0x88, 0xfc, 0x9a, 0x8e, 0x51, 0x48, 0x67, 0x5e, 0x48, 0x13, 0x19, 0x90, 0x04, 0xf3, 0xc9, 0x7a, 0x18, 0x30, 0xe2, 0x09, 0xcc, 0x33, 0x12, 0x62, 0xe1, 0x91, 0x44, 0x72, 0x2a, 0x18, 0x0e, 0x25, 0xa1, 0x89, 0x97, 0x9d, 0x6d, 0x02, 0x88, 0x71, 0x2a, 0x29, 0x7c, 0xf1, 0xc0, 0x46, 0x15, 0x13, 0x6d, 0x36, 0x66, 0x67, 0xce, 0xf9, 0x56, 0x9b, 0xe5, 0x9c, 0x61, 0xe1, 0xb1, 0x38, 0x90, 0x53, 0xca, 0x67, 0x7a, 0x81, 0xf3, 0x34, 0xa2, 0x34, 0x8a, 0xb1, 0xc7, 0x59, 0xe8, 0x09, 0x19, 0xc8, 0x54, 0x94, 0x85, 0x67, 0x65, 0x41, 0x65, 0xe3, 0x74, 0xea, 0xe1, 0x19, 0x93, 0xf3, 0xb2, 0x78, 0x12, 0xd1, 0x88, 0xaa, 0xd0, 0x2b, 0x22, 0x8d, 0x76, 0xfe, 0x9a, 0xa0, 0x71, 0x1d, 0xa7, 0x11, 0x49, 0x20, 0x04, 0xf5, 0x62, 0x9d, 0x6d, 0xb4, 0x8d, 0xee, 0xa1, 0xaf, 0x62, 0x78, 0x0a, 0x4c, 0x32, 0xb1, 0xcd, 0x02, 0xe9, 0x37, 0xf2, 0x65, 0xcb, 0x1c, 0x5e, 0xfa, 0x26, 0x99, 0x40, 0x07, 0x1c, 0x70, 0x7c, 0x97, 0x12, 0x8e, 0x85, 0x5d, 0x6b, 0xd7, 0xba, 0x87, 0xfe, 0x2a, 0x87, 0x1f, 0xc1, 0x61, 0x25, 0x58, 0xd8, 0xf5, 0x76, 0xad, 0xdb, 0xec, 0x39, 0x68, 0xcd, 0x13, 0x75, 0x13, 0xba, 0x2e, 0x5b, 0xfa, 0xf5, 0xc5, 0xb2, 0xb5, 0xe7, 0x3f, 0x50, 0xe0, 0x08, 0x58, 0xf8, 0x3b, 0xa3, 0x5c, 0x0a, 0x7b, 0x5f, 0xb1, 0xcf, 0xd1, 0x36, 0x8e, 0x22, 0x7d, 0x06, 0x1a, 0x68, 0xee, 0x20, 0x91, 0x7c, 0xee, 0x57, 0x93, 0x60, 0x07, 0x1c, 0x85, 0x01, 0x0b, 0xc6, 0x24, 0x26, 0x92, 0x60, 0x61, 0x37, 0x94, 0xe8, 0x0d, 0x0c, 0xbe, 0x06, 0x07, 0x24, 0x21, 0xf2, 0x16, 0x73, 0x6e, 0x5b, 0x6d, 0xa3, 0xdb, 0xec, 0x41, 0xa4, 0x1d, 0x45, 0x9c, 0x85, 0x68, 0xa4, 0xac, 0xf6, 0xad, 0xa2, 0x67, 0xc0, 0xb9, 0x73, 0x01, 0x8e, 0xd6, 0x77, 0xc1, 0x27, 0xa0, 0xf6, 0x0d, 0xcf, 0x4b, 0xfb, 0x8a, 0x10, 0x9e, 0x80, 0xfd, 0x2c, 0x88, 0x53, 0xac, 0x0d, 0xf4, 0x75, 0x72, 0x61, 0xbe, 0x37, 0x3a, 0x2f, 0xc1, 0xb1, 0x96, 0x2b, 0x7c, 0x7c, 0x97, 0x62, 0x21, 0xa1, 0x0d, 0xac, 0x29, 0x89, 0x25, 0xe6, 0xc2, 0x36, 0x94, 0xb6, 0x2a, 0xed, 0xdc, 0x82, 0xc7, 0xab, 0x5e, 0xc1, 0x68, 0x22, 0x30, 0xbc, 0x02, 0x16, 0xd3, 0x90, 0x6a, 0x6e, 0xf6, 0x5e, 0xed, 0x62, 0x51, 0x69, 0x79, 0x35, 0xa2, 0x83, 0xc0, 0xf1, 0x08, 0xf3, 0x0c, 0xf3, 0xd5, 0xfc, 0xe7, 0xa0, 0x9e, 0xa6, 0x64, 0xa2, 0x6f, 0xe9, 0x1f, 0xe4, 0xcb, 0x56, 0xfd, 0xe6, 0x66, 0x78, 0xe9, 0x2b, 0xb4, 0xf7, 0xdb, 0x00, 0x8f, 0x86, 0xeb, 0xa3, 0x61, 0x06, 0xac, 0x52, 0x22, 0x7c, 0xbb, 0x8b, 0x92, 0xea, 0x7a, 0xe7, 0xdd, 0x8e, 0xac, 0x52, 0xe7, 0x27, 0xd0, 0xd0, 0xca, 0xe1, 0x69, 0xf5, 0xa5, 0xaa, 0xb7, 0x8f, 0x06, 0xc5, 0xdb, 0x77, 0xb6, 0x94, 0xb3, 0x79, 0x7f, 0x7f, 0xba, 0xb8, 0x77, 0xf7, 0x7e, 0xdd, 0xbb, 0x7b, 0x3f, 0x72, 0xd7, 0x58, 0xe4, 0xae, 0xf1, 0x33, 0x77, 0x8d, 0x3f, 0xb9, 0x6b, 0x7c, 0xb9, 0xfa, 0xbf, 0x1f, 0xc6, 0x87, 0x0d, 0xe0, 0x73, 0x6d, 0xdc, 0x50, 0x7a, 0xdf, 0xfc, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x0c, 0xb3, 0x50, 0xdc, 0x89, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // IntrospectionClient is the client API for Introspection service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type IntrospectionClient interface { // Plugins returns a list of plugins in containerd. // // Clients can use this to detect features and capabilities when using // containerd. Plugins(ctx context.Context, in *PluginsRequest, opts ...grpc.CallOption) (*PluginsResponse, error) // Server returns information about the containerd server Server(ctx context.Context, in *types1.Empty, opts ...grpc.CallOption) (*ServerResponse, error) } type introspectionClient struct { cc *grpc.ClientConn } func NewIntrospectionClient(cc *grpc.ClientConn) IntrospectionClient { return &introspectionClient{cc} } func (c *introspectionClient) Plugins(ctx context.Context, in *PluginsRequest, opts ...grpc.CallOption) (*PluginsResponse, error) { out := new(PluginsResponse) err := c.cc.Invoke(ctx, "/containerd.services.introspection.v1.Introspection/Plugins", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *introspectionClient) Server(ctx context.Context, in *types1.Empty, opts ...grpc.CallOption) (*ServerResponse, error) { out := new(ServerResponse) err := c.cc.Invoke(ctx, "/containerd.services.introspection.v1.Introspection/Server", in, out, opts...) if err != nil { return nil, err } return out, nil } // IntrospectionServer is the server API for Introspection service. type IntrospectionServer interface { // Plugins returns a list of plugins in containerd. // // Clients can use this to detect features and capabilities when using // containerd. Plugins(context.Context, *PluginsRequest) (*PluginsResponse, error) // Server returns information about the containerd server Server(context.Context, *types1.Empty) (*ServerResponse, error) } // UnimplementedIntrospectionServer can be embedded to have forward compatible implementations. type UnimplementedIntrospectionServer struct { } func (*UnimplementedIntrospectionServer) Plugins(ctx context.Context, req *PluginsRequest) (*PluginsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Plugins not implemented") } func (*UnimplementedIntrospectionServer) Server(ctx context.Context, req *types1.Empty) (*ServerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Server not implemented") } func RegisterIntrospectionServer(s *grpc.Server, srv IntrospectionServer) { s.RegisterService(&_Introspection_serviceDesc, srv) } func _Introspection_Plugins_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PluginsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(IntrospectionServer).Plugins(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.introspection.v1.Introspection/Plugins", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(IntrospectionServer).Plugins(ctx, req.(*PluginsRequest)) } return interceptor(ctx, in, info, handler) } func _Introspection_Server_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(types1.Empty) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(IntrospectionServer).Server(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.introspection.v1.Introspection/Server", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(IntrospectionServer).Server(ctx, req.(*types1.Empty)) } return interceptor(ctx, in, info, handler) } var _Introspection_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.introspection.v1.Introspection", HandlerType: (*IntrospectionServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Plugins", Handler: _Introspection_Plugins_Handler, }, { MethodName: "Server", Handler: _Introspection_Server_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/introspection/v1/introspection.proto", } func (m *Plugin) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Plugin) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Plugin) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.InitErr != nil { { size, err := m.InitErr.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintIntrospection(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x3a } if len(m.Capabilities) > 0 { for iNdEx := len(m.Capabilities) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Capabilities[iNdEx]) copy(dAtA[i:], m.Capabilities[iNdEx]) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.Capabilities[iNdEx]))) i-- dAtA[i] = 0x32 } } if len(m.Exports) > 0 { for k := range m.Exports { v := m.Exports[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintIntrospection(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintIntrospection(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintIntrospection(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x2a } } if len(m.Platforms) > 0 { for iNdEx := len(m.Platforms) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Platforms[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintIntrospection(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } } if len(m.Requires) > 0 { for iNdEx := len(m.Requires) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Requires[iNdEx]) copy(dAtA[i:], m.Requires[iNdEx]) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.Requires[iNdEx]))) i-- dAtA[i] = 0x1a } } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0x12 } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PluginsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PluginsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PluginsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *PluginsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PluginsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PluginsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Plugins) > 0 { for iNdEx := len(m.Plugins) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Plugins[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintIntrospection(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ServerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ServerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.UUID) > 0 { i -= len(m.UUID) copy(dAtA[i:], m.UUID) i = encodeVarintIntrospection(dAtA, i, uint64(len(m.UUID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintIntrospection(dAtA []byte, offset int, v uint64) int { offset -= sovIntrospection(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Plugin) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Type) if l > 0 { n += 1 + l + sovIntrospection(uint64(l)) } l = len(m.ID) if l > 0 { n += 1 + l + sovIntrospection(uint64(l)) } if len(m.Requires) > 0 { for _, s := range m.Requires { l = len(s) n += 1 + l + sovIntrospection(uint64(l)) } } if len(m.Platforms) > 0 { for _, e := range m.Platforms { l = e.Size() n += 1 + l + sovIntrospection(uint64(l)) } } if len(m.Exports) > 0 { for k, v := range m.Exports { _ = k _ = v mapEntrySize := 1 + len(k) + sovIntrospection(uint64(len(k))) + 1 + len(v) + sovIntrospection(uint64(len(v))) n += mapEntrySize + 1 + sovIntrospection(uint64(mapEntrySize)) } } if len(m.Capabilities) > 0 { for _, s := range m.Capabilities { l = len(s) n += 1 + l + sovIntrospection(uint64(l)) } } if m.InitErr != nil { l = m.InitErr.Size() n += 1 + l + sovIntrospection(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PluginsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovIntrospection(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PluginsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Plugins) > 0 { for _, e := range m.Plugins { l = e.Size() n += 1 + l + sovIntrospection(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.UUID) if l > 0 { n += 1 + l + sovIntrospection(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovIntrospection(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozIntrospection(x uint64) (n int) { return sovIntrospection(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Plugin) String() string { if this == nil { return "nil" } repeatedStringForPlatforms := "[]Platform{" for _, f := range this.Platforms { repeatedStringForPlatforms += fmt.Sprintf("%v", f) + "," } repeatedStringForPlatforms += "}" keysForExports := make([]string, 0, len(this.Exports)) for k, _ := range this.Exports { keysForExports = append(keysForExports, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForExports) mapStringForExports := "map[string]string{" for _, k := range keysForExports { mapStringForExports += fmt.Sprintf("%v: %v,", k, this.Exports[k]) } mapStringForExports += "}" s := strings.Join([]string{`&Plugin{`, `Type:` + fmt.Sprintf("%v", this.Type) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Requires:` + fmt.Sprintf("%v", this.Requires) + `,`, `Platforms:` + repeatedStringForPlatforms + `,`, `Exports:` + mapStringForExports + `,`, `Capabilities:` + fmt.Sprintf("%v", this.Capabilities) + `,`, `InitErr:` + strings.Replace(fmt.Sprintf("%v", this.InitErr), "Status", "rpc.Status", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *PluginsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PluginsRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *PluginsResponse) String() string { if this == nil { return "nil" } repeatedStringForPlugins := "[]Plugin{" for _, f := range this.Plugins { repeatedStringForPlugins += strings.Replace(strings.Replace(f.String(), "Plugin", "Plugin", 1), `&`, ``, 1) + "," } repeatedStringForPlugins += "}" s := strings.Join([]string{`&PluginsResponse{`, `Plugins:` + repeatedStringForPlugins + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ServerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ServerResponse{`, `UUID:` + fmt.Sprintf("%v", this.UUID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringIntrospection(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Plugin) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Plugin: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Plugin: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requires", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Requires = append(m.Requires, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Platforms", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Platforms = append(m.Platforms, types.Platform{}) if err := m.Platforms[len(m.Platforms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Exports", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } if m.Exports == nil { m.Exports = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthIntrospection } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthIntrospection } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthIntrospection } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthIntrospection } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipIntrospection(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthIntrospection } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Exports[mapkey] = mapvalue iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Capabilities = append(m.Capabilities, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field InitErr", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } if m.InitErr == nil { m.InitErr = &rpc.Status{} } if err := m.InitErr.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipIntrospection(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthIntrospection } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PluginsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PluginsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PluginsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipIntrospection(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthIntrospection } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PluginsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PluginsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PluginsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Plugins", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.Plugins = append(m.Plugins, Plugin{}) if err := m.Plugins[len(m.Plugins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipIntrospection(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthIntrospection } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ServerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ServerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowIntrospection } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthIntrospection } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthIntrospection } if postIndex > l { return io.ErrUnexpectedEOF } m.UUID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipIntrospection(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthIntrospection } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipIntrospection(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowIntrospection } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowIntrospection } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowIntrospection } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthIntrospection } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupIntrospection } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthIntrospection } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthIntrospection = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowIntrospection = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupIntrospection = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/introspection/v1/introspection.proto000066400000000000000000000065311416535272200254770ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.introspection.v1; import "github.com/containerd/containerd/api/types/platform.proto"; import "google/rpc/status.proto"; import "google/protobuf/empty.proto"; import weak "gogoproto/gogo.proto"; option go_package = "github.com/containerd/containerd/api/services/introspection/v1;introspection"; service Introspection { // Plugins returns a list of plugins in containerd. // // Clients can use this to detect features and capabilities when using // containerd. rpc Plugins(PluginsRequest) returns (PluginsResponse); // Server returns information about the containerd server rpc Server(google.protobuf.Empty) returns (ServerResponse); } message Plugin { // Type defines the type of plugin. // // See package plugin for a list of possible values. Non core plugins may // define their own values during registration. string type = 1; // ID identifies the plugin uniquely in the system. string id = 2; // Requires lists the plugin types required by this plugin. repeated string requires = 3; // Platforms enumerates the platforms this plugin will support. // // If values are provided here, the plugin will only be operable under the // provided platforms. // // If this is empty, the plugin will work across all platforms. // // If the plugin prefers certain platforms over others, they should be // listed from most to least preferred. repeated types.Platform platforms = 4 [(gogoproto.nullable) = false]; // Exports allows plugins to provide values about state or configuration to // interested parties. // // One example is exposing the configured path of a snapshotter plugin. map exports = 5; // Capabilities allows plugins to communicate feature switches to allow // clients to detect features that may not be on be default or may be // different from version to version. // // Use this sparingly. repeated string capabilities = 6; // InitErr will be set if the plugin fails initialization. // // This means the plugin may have been registered but a non-terminal error // was encountered during initialization. // // Plugins that have this value set cannot be used. google.rpc.Status init_err = 7; } message PluginsRequest { // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, plugins that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. repeated string filters = 1; } message PluginsResponse { repeated Plugin plugins = 1 [(gogoproto.nullable) = false]; } message ServerResponse { string uuid = 1 [(gogoproto.customname) = "UUID"]; } containerd-1.5.9/api/services/leases/000077500000000000000000000000001416535272200175335ustar00rootroot00000000000000containerd-1.5.9/api/services/leases/v1/000077500000000000000000000000001416535272200200615ustar00rootroot00000000000000containerd-1.5.9/api/services/leases/v1/doc.go000066400000000000000000000011431416535272200211540ustar00rootroot00000000000000/* Copyright The containerd 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 leases containerd-1.5.9/api/services/leases/v1/leases.pb.go000066400000000000000000002414041416535272200222710ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/leases/v1/leases.proto package leases import ( context "context" fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Lease is an object which retains resources while it exists. type Lease struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` CreatedAt time.Time `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Lease) Reset() { *m = Lease{} } func (*Lease) ProtoMessage() {} func (*Lease) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{0} } func (m *Lease) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Lease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Lease.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Lease) XXX_Merge(src proto.Message) { xxx_messageInfo_Lease.Merge(m, src) } func (m *Lease) XXX_Size() int { return m.Size() } func (m *Lease) XXX_DiscardUnknown() { xxx_messageInfo_Lease.DiscardUnknown(m) } var xxx_messageInfo_Lease proto.InternalMessageInfo type CreateRequest struct { // ID is used to identity the lease, when the id is not set the service // generates a random identifier for the lease. ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateRequest) Reset() { *m = CreateRequest{} } func (*CreateRequest) ProtoMessage() {} func (*CreateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{1} } func (m *CreateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateRequest.Merge(m, src) } func (m *CreateRequest) XXX_Size() int { return m.Size() } func (m *CreateRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateRequest proto.InternalMessageInfo type CreateResponse struct { Lease *Lease `protobuf:"bytes,1,opt,name=lease,proto3" json:"lease,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateResponse) Reset() { *m = CreateResponse{} } func (*CreateResponse) ProtoMessage() {} func (*CreateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{2} } func (m *CreateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateResponse.Merge(m, src) } func (m *CreateResponse) XXX_Size() int { return m.Size() } func (m *CreateResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateResponse proto.InternalMessageInfo type DeleteRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Sync indicates that the delete and cleanup should be done // synchronously before returning to the caller // // Default is false Sync bool `protobuf:"varint,2,opt,name=sync,proto3" json:"sync,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } func (*DeleteRequest) ProtoMessage() {} func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{3} } func (m *DeleteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRequest.Merge(m, src) } func (m *DeleteRequest) XXX_Size() int { return m.Size() } func (m *DeleteRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo type ListRequest struct { Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListRequest) Reset() { *m = ListRequest{} } func (*ListRequest) ProtoMessage() {} func (*ListRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{4} } func (m *ListRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListRequest.Merge(m, src) } func (m *ListRequest) XXX_Size() int { return m.Size() } func (m *ListRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListRequest.DiscardUnknown(m) } var xxx_messageInfo_ListRequest proto.InternalMessageInfo type ListResponse struct { Leases []*Lease `protobuf:"bytes,1,rep,name=leases,proto3" json:"leases,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListResponse) Reset() { *m = ListResponse{} } func (*ListResponse) ProtoMessage() {} func (*ListResponse) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{5} } func (m *ListResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListResponse.Merge(m, src) } func (m *ListResponse) XXX_Size() int { return m.Size() } func (m *ListResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListResponse.DiscardUnknown(m) } var xxx_messageInfo_ListResponse proto.InternalMessageInfo type Resource struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // For snapshotter resource, there are many snapshotter types here, like // overlayfs, devmapper etc. The type will be formatted with type, // like "snapshotter/overlayfs". Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Resource) Reset() { *m = Resource{} } func (*Resource) ProtoMessage() {} func (*Resource) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{6} } func (m *Resource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Resource.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Resource) XXX_Merge(src proto.Message) { xxx_messageInfo_Resource.Merge(m, src) } func (m *Resource) XXX_Size() int { return m.Size() } func (m *Resource) XXX_DiscardUnknown() { xxx_messageInfo_Resource.DiscardUnknown(m) } var xxx_messageInfo_Resource proto.InternalMessageInfo type AddResourceRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Resource Resource `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AddResourceRequest) Reset() { *m = AddResourceRequest{} } func (*AddResourceRequest) ProtoMessage() {} func (*AddResourceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{7} } func (m *AddResourceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AddResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AddResourceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *AddResourceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AddResourceRequest.Merge(m, src) } func (m *AddResourceRequest) XXX_Size() int { return m.Size() } func (m *AddResourceRequest) XXX_DiscardUnknown() { xxx_messageInfo_AddResourceRequest.DiscardUnknown(m) } var xxx_messageInfo_AddResourceRequest proto.InternalMessageInfo type DeleteResourceRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Resource Resource `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteResourceRequest) Reset() { *m = DeleteResourceRequest{} } func (*DeleteResourceRequest) ProtoMessage() {} func (*DeleteResourceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{8} } func (m *DeleteResourceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteResourceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteResourceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteResourceRequest.Merge(m, src) } func (m *DeleteResourceRequest) XXX_Size() int { return m.Size() } func (m *DeleteResourceRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteResourceRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteResourceRequest proto.InternalMessageInfo type ListResourcesRequest struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListResourcesRequest) Reset() { *m = ListResourcesRequest{} } func (*ListResourcesRequest) ProtoMessage() {} func (*ListResourcesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{9} } func (m *ListResourcesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListResourcesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListResourcesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListResourcesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListResourcesRequest.Merge(m, src) } func (m *ListResourcesRequest) XXX_Size() int { return m.Size() } func (m *ListResourcesRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListResourcesRequest.DiscardUnknown(m) } var xxx_messageInfo_ListResourcesRequest proto.InternalMessageInfo type ListResourcesResponse struct { Resources []Resource `protobuf:"bytes,1,rep,name=resources,proto3" json:"resources"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListResourcesResponse) Reset() { *m = ListResourcesResponse{} } func (*ListResourcesResponse) ProtoMessage() {} func (*ListResourcesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_fefd70dfe8d93cbf, []int{10} } func (m *ListResourcesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListResourcesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListResourcesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListResourcesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListResourcesResponse.Merge(m, src) } func (m *ListResourcesResponse) XXX_Size() int { return m.Size() } func (m *ListResourcesResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListResourcesResponse.DiscardUnknown(m) } var xxx_messageInfo_ListResourcesResponse proto.InternalMessageInfo func init() { proto.RegisterType((*Lease)(nil), "containerd.services.leases.v1.Lease") proto.RegisterMapType((map[string]string)(nil), "containerd.services.leases.v1.Lease.LabelsEntry") proto.RegisterType((*CreateRequest)(nil), "containerd.services.leases.v1.CreateRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.leases.v1.CreateRequest.LabelsEntry") proto.RegisterType((*CreateResponse)(nil), "containerd.services.leases.v1.CreateResponse") proto.RegisterType((*DeleteRequest)(nil), "containerd.services.leases.v1.DeleteRequest") proto.RegisterType((*ListRequest)(nil), "containerd.services.leases.v1.ListRequest") proto.RegisterType((*ListResponse)(nil), "containerd.services.leases.v1.ListResponse") proto.RegisterType((*Resource)(nil), "containerd.services.leases.v1.Resource") proto.RegisterType((*AddResourceRequest)(nil), "containerd.services.leases.v1.AddResourceRequest") proto.RegisterType((*DeleteResourceRequest)(nil), "containerd.services.leases.v1.DeleteResourceRequest") proto.RegisterType((*ListResourcesRequest)(nil), "containerd.services.leases.v1.ListResourcesRequest") proto.RegisterType((*ListResourcesResponse)(nil), "containerd.services.leases.v1.ListResourcesResponse") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/leases/v1/leases.proto", fileDescriptor_fefd70dfe8d93cbf) } var fileDescriptor_fefd70dfe8d93cbf = []byte{ // 644 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x6e, 0xd3, 0x40, 0x10, 0xce, 0x26, 0xa9, 0x49, 0x26, 0xb4, 0x42, 0xab, 0xb6, 0x8a, 0x8c, 0x48, 0x22, 0x0b, 0xa9, 0x11, 0x3f, 0x36, 0x4d, 0x2b, 0x54, 0x5a, 0x84, 0xd4, 0xb4, 0x95, 0xa8, 0x88, 0x10, 0xb2, 0x38, 0x54, 0x1c, 0xa8, 0x1c, 0x7b, 0x1b, 0x2c, 0x9c, 0xd8, 0x78, 0x37, 0x41, 0xe9, 0x89, 0x47, 0xe0, 0x61, 0x78, 0x88, 0x1e, 0x39, 0x21, 0x4e, 0x85, 0xe6, 0xc6, 0x5b, 0x20, 0xef, 0x0f, 0x6d, 0x5a, 0xb5, 0x76, 0x11, 0xe2, 0x36, 0x1b, 0x7f, 0xdf, 0xcc, 0x37, 0x33, 0xdf, 0x6e, 0x60, 0xbb, 0xe7, 0xb3, 0x77, 0xc3, 0xae, 0xe9, 0x86, 0x7d, 0xcb, 0x0d, 0x07, 0xcc, 0xf1, 0x07, 0x24, 0xf6, 0xce, 0x86, 0x4e, 0xe4, 0x5b, 0x94, 0xc4, 0x23, 0xdf, 0x25, 0xd4, 0x0a, 0x88, 0x43, 0x09, 0xb5, 0x46, 0xcb, 0x32, 0x32, 0xa3, 0x38, 0x64, 0x21, 0xbe, 0x73, 0x8a, 0x37, 0x15, 0xd6, 0x94, 0x88, 0xd1, 0xb2, 0x3e, 0xdf, 0x0b, 0x7b, 0x21, 0x47, 0x5a, 0x49, 0x24, 0x48, 0xfa, 0xed, 0x5e, 0x18, 0xf6, 0x02, 0x62, 0xf1, 0x53, 0x77, 0x78, 0x60, 0x91, 0x7e, 0xc4, 0xc6, 0xf2, 0x63, 0xfd, 0xfc, 0x47, 0xe6, 0xf7, 0x09, 0x65, 0x4e, 0x3f, 0x12, 0x00, 0xe3, 0x17, 0x82, 0x99, 0x4e, 0x52, 0x01, 0x2f, 0x42, 0xde, 0xf7, 0xaa, 0xa8, 0x81, 0x9a, 0xe5, 0xb6, 0x36, 0x39, 0xae, 0xe7, 0x77, 0xb7, 0xed, 0xbc, 0xef, 0xe1, 0x2d, 0x00, 0x37, 0x26, 0x0e, 0x23, 0xde, 0xbe, 0xc3, 0xaa, 0xf9, 0x06, 0x6a, 0x56, 0x5a, 0xba, 0x29, 0xf2, 0x9a, 0x2a, 0xaf, 0xf9, 0x5a, 0xe5, 0x6d, 0x97, 0x8e, 0x8e, 0xeb, 0xb9, 0xcf, 0x3f, 0xea, 0xc8, 0x2e, 0x4b, 0xde, 0x26, 0xc3, 0xcf, 0x41, 0x0b, 0x9c, 0x2e, 0x09, 0x68, 0xb5, 0xd0, 0x28, 0x34, 0x2b, 0xad, 0x47, 0xe6, 0x95, 0xad, 0x9a, 0x5c, 0x92, 0xd9, 0xe1, 0x94, 0x9d, 0x01, 0x8b, 0xc7, 0xb6, 0xe4, 0xeb, 0x4f, 0xa0, 0x72, 0xe6, 0x67, 0x7c, 0x0b, 0x0a, 0xef, 0xc9, 0x58, 0xc8, 0xb6, 0x93, 0x10, 0xcf, 0xc3, 0xcc, 0xc8, 0x09, 0x86, 0x84, 0x4b, 0x2d, 0xdb, 0xe2, 0xb0, 0x9e, 0x5f, 0x43, 0xc6, 0x17, 0x04, 0xb3, 0x5b, 0x5c, 0x92, 0x4d, 0x3e, 0x0c, 0x09, 0x65, 0x97, 0xf6, 0xfc, 0xea, 0x9c, 0xdc, 0xb5, 0x14, 0xb9, 0x53, 0x59, 0xff, 0xb5, 0xec, 0x0e, 0xcc, 0xa9, 0xfc, 0x34, 0x0a, 0x07, 0x94, 0xe0, 0x75, 0x98, 0xe1, 0xb5, 0x39, 0xbf, 0xd2, 0xba, 0x9b, 0x65, 0x98, 0xb6, 0xa0, 0x18, 0x1b, 0x30, 0xbb, 0x4d, 0x02, 0x92, 0x3e, 0x03, 0x0c, 0x45, 0x3a, 0x1e, 0xb8, 0x5c, 0x4f, 0xc9, 0xe6, 0xb1, 0xb1, 0x04, 0x95, 0x8e, 0x4f, 0x99, 0xa2, 0x56, 0xe1, 0xc6, 0x81, 0x1f, 0x30, 0x12, 0xd3, 0x2a, 0x6a, 0x14, 0x9a, 0x65, 0x5b, 0x1d, 0x8d, 0x0e, 0xdc, 0x14, 0x40, 0xa9, 0xf8, 0x29, 0x68, 0x42, 0x0f, 0x07, 0x66, 0x95, 0x2c, 0x39, 0xc6, 0x63, 0x28, 0xd9, 0x84, 0x86, 0xc3, 0xd8, 0x25, 0x57, 0xc9, 0x65, 0xe3, 0x48, 0x8d, 0x8f, 0xc7, 0xc6, 0x47, 0xc0, 0x9b, 0x9e, 0xa7, 0xa8, 0x69, 0x0d, 0xef, 0x42, 0x29, 0x96, 0x50, 0x69, 0xf3, 0xa5, 0x14, 0x95, 0x2a, 0x73, 0xbb, 0x98, 0x78, 0xde, 0xfe, 0x43, 0x37, 0x0e, 0x61, 0x41, 0x0d, 0xf9, 0xbf, 0xd7, 0x36, 0x61, 0x5e, 0x8e, 0x9e, 0x9f, 0x69, 0x4a, 0x69, 0xc3, 0x83, 0x85, 0x73, 0x78, 0xb9, 0xb3, 0x17, 0x50, 0x56, 0x49, 0xd5, 0xda, 0xae, 0x29, 0xea, 0x94, 0xdf, 0xfa, 0x56, 0x04, 0x8d, 0x2f, 0x95, 0x62, 0x02, 0x9a, 0xf0, 0x33, 0x7e, 0x70, 0x9d, 0x6b, 0xa5, 0x3f, 0xcc, 0x88, 0x96, 0xf2, 0x5f, 0x82, 0x26, 0x76, 0x90, 0x5a, 0x66, 0xea, 0x3e, 0xe8, 0x8b, 0x17, 0xde, 0xb6, 0x9d, 0xe4, 0x41, 0xc5, 0xfb, 0x50, 0x4c, 0xe6, 0x84, 0xef, 0xa5, 0x59, 0xf7, 0xf4, 0x82, 0xe8, 0xf7, 0x33, 0x61, 0xa5, 0xe0, 0x3d, 0xa8, 0x9c, 0x71, 0x2b, 0x5e, 0x4e, 0xe1, 0x5e, 0x74, 0xf6, 0xa5, 0xd2, 0xdf, 0xc2, 0xdc, 0xb4, 0x1d, 0xf1, 0x6a, 0xc6, 0x91, 0x64, 0xcb, 0x7f, 0x08, 0xb3, 0x53, 0x16, 0xc2, 0x2b, 0xd9, 0xfa, 0x9e, 0x32, 0xa8, 0xbe, 0x7a, 0x3d, 0x92, 0x98, 0x5a, 0x7b, 0xef, 0xe8, 0xa4, 0x96, 0xfb, 0x7e, 0x52, 0xcb, 0x7d, 0x9a, 0xd4, 0xd0, 0xd1, 0xa4, 0x86, 0xbe, 0x4e, 0x6a, 0xe8, 0xe7, 0xa4, 0x86, 0xde, 0x3c, 0xfb, 0xcb, 0xff, 0xe4, 0x0d, 0x11, 0xed, 0xe5, 0xba, 0x1a, 0xef, 0x73, 0xe5, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0d, 0xfe, 0x39, 0x67, 0xde, 0x07, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // LeasesClient is the client API for Leases service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type LeasesClient interface { // Create creates a new lease for managing changes to metadata. A lease // can be used to protect objects from being removed. Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) // Delete deletes the lease and makes any unreferenced objects created // during the lease eligible for garbage collection if not referenced // or retained by other resources during the lease. Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*types.Empty, error) // List lists all active leases, returning the full list of // leases and optionally including the referenced resources. List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) // AddResource references the resource by the provided lease. AddResource(ctx context.Context, in *AddResourceRequest, opts ...grpc.CallOption) (*types.Empty, error) // DeleteResource dereferences the resource by the provided lease. DeleteResource(ctx context.Context, in *DeleteResourceRequest, opts ...grpc.CallOption) (*types.Empty, error) // ListResources lists all the resources referenced by the lease. ListResources(ctx context.Context, in *ListResourcesRequest, opts ...grpc.CallOption) (*ListResourcesResponse, error) } type leasesClient struct { cc *grpc.ClientConn } func NewLeasesClient(cc *grpc.ClientConn) LeasesClient { return &leasesClient{cc} } func (c *leasesClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) { out := new(CreateResponse) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *leasesClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *leasesClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) { out := new(ListResponse) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/List", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *leasesClient) AddResource(ctx context.Context, in *AddResourceRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/AddResource", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *leasesClient) DeleteResource(ctx context.Context, in *DeleteResourceRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/DeleteResource", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *leasesClient) ListResources(ctx context.Context, in *ListResourcesRequest, opts ...grpc.CallOption) (*ListResourcesResponse, error) { out := new(ListResourcesResponse) err := c.cc.Invoke(ctx, "/containerd.services.leases.v1.Leases/ListResources", in, out, opts...) if err != nil { return nil, err } return out, nil } // LeasesServer is the server API for Leases service. type LeasesServer interface { // Create creates a new lease for managing changes to metadata. A lease // can be used to protect objects from being removed. Create(context.Context, *CreateRequest) (*CreateResponse, error) // Delete deletes the lease and makes any unreferenced objects created // during the lease eligible for garbage collection if not referenced // or retained by other resources during the lease. Delete(context.Context, *DeleteRequest) (*types.Empty, error) // List lists all active leases, returning the full list of // leases and optionally including the referenced resources. List(context.Context, *ListRequest) (*ListResponse, error) // AddResource references the resource by the provided lease. AddResource(context.Context, *AddResourceRequest) (*types.Empty, error) // DeleteResource dereferences the resource by the provided lease. DeleteResource(context.Context, *DeleteResourceRequest) (*types.Empty, error) // ListResources lists all the resources referenced by the lease. ListResources(context.Context, *ListResourcesRequest) (*ListResourcesResponse, error) } // UnimplementedLeasesServer can be embedded to have forward compatible implementations. type UnimplementedLeasesServer struct { } func (*UnimplementedLeasesServer) Create(ctx context.Context, req *CreateRequest) (*CreateResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") } func (*UnimplementedLeasesServer) Delete(ctx context.Context, req *DeleteRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func (*UnimplementedLeasesServer) List(ctx context.Context, req *ListRequest) (*ListResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedLeasesServer) AddResource(ctx context.Context, req *AddResourceRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method AddResource not implemented") } func (*UnimplementedLeasesServer) DeleteResource(ctx context.Context, req *DeleteResourceRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method DeleteResource not implemented") } func (*UnimplementedLeasesServer) ListResources(ctx context.Context, req *ListResourcesRequest) (*ListResourcesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListResources not implemented") } func RegisterLeasesServer(s *grpc.Server, srv LeasesServer) { s.RegisterService(&_Leases_serviceDesc, srv) } func _Leases_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.(LeasesServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).Create(ctx, req.(*CreateRequest)) } return interceptor(ctx, in, info, handler) } func _Leases_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.(LeasesServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).Delete(ctx, req.(*DeleteRequest)) } return interceptor(ctx, in, info, handler) } func _Leases_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.(LeasesServer).List(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/List", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).List(ctx, req.(*ListRequest)) } return interceptor(ctx, in, info, handler) } func _Leases_AddResource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AddResourceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(LeasesServer).AddResource(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/AddResource", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).AddResource(ctx, req.(*AddResourceRequest)) } return interceptor(ctx, in, info, handler) } func _Leases_DeleteResource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteResourceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(LeasesServer).DeleteResource(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/DeleteResource", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).DeleteResource(ctx, req.(*DeleteResourceRequest)) } return interceptor(ctx, in, info, handler) } func _Leases_ListResources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListResourcesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(LeasesServer).ListResources(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.leases.v1.Leases/ListResources", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(LeasesServer).ListResources(ctx, req.(*ListResourcesRequest)) } return interceptor(ctx, in, info, handler) } var _Leases_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.leases.v1.Leases", HandlerType: (*LeasesServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Create", Handler: _Leases_Create_Handler, }, { MethodName: "Delete", Handler: _Leases_Delete_Handler, }, { MethodName: "List", Handler: _Leases_List_Handler, }, { MethodName: "AddResource", Handler: _Leases_AddResource_Handler, }, { MethodName: "DeleteResource", Handler: _Leases_DeleteResource_Handler, }, { MethodName: "ListResources", Handler: _Leases_ListResources_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/leases/v1/leases.proto", } func (m *Lease) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Lease) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintLeases(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintLeases(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintLeases(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) if err1 != nil { return 0, err1 } i -= n1 i = encodeVarintLeases(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x12 if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CreateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintLeases(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintLeases(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintLeases(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CreateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Lease != nil { { size, err := m.Lease.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintLeases(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Sync { i-- if m.Sync { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintLeases(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ListResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Leases) > 0 { for iNdEx := len(m.Leases) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Leases[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintLeases(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *Resource) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Resource) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Resource) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = encodeVarintLeases(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0x12 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *AddResourceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AddResourceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *AddResourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintLeases(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DeleteResourceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteResourceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteResourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintLeases(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListResourcesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListResourcesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListResourcesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintLeases(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListResourcesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListResourcesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListResourcesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Resources) > 0 { for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Resources[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintLeases(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func encodeVarintLeases(dAtA []byte, offset int, v uint64) int { offset -= sovLeases(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Lease) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) n += 1 + l + sovLeases(uint64(l)) if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovLeases(uint64(len(k))) + 1 + len(v) + sovLeases(uint64(len(v))) n += mapEntrySize + 1 + sovLeases(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovLeases(uint64(len(k))) + 1 + len(v) + sovLeases(uint64(len(v))) n += mapEntrySize + 1 + sovLeases(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Lease != nil { l = m.Lease.Size() n += 1 + l + sovLeases(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } if m.Sync { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovLeases(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Leases) > 0 { for _, e := range m.Leases { l = e.Size() n += 1 + l + sovLeases(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Resource) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } l = len(m.Type) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AddResourceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } l = m.Resource.Size() n += 1 + l + sovLeases(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteResourceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } l = m.Resource.Size() n += 1 + l + sovLeases(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListResourcesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovLeases(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListResourcesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Resources) > 0 { for _, e := range m.Resources { l = e.Size() n += 1 + l + sovLeases(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovLeases(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozLeases(x uint64) (n int) { return sovLeases(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Lease) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&Lease{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateRequest) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&CreateRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateResponse{`, `Lease:` + strings.Replace(this.Lease.String(), "Lease", "Lease", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Sync:` + fmt.Sprintf("%v", this.Sync) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListResponse) String() string { if this == nil { return "nil" } repeatedStringForLeases := "[]*Lease{" for _, f := range this.Leases { repeatedStringForLeases += strings.Replace(f.String(), "Lease", "Lease", 1) + "," } repeatedStringForLeases += "}" s := strings.Join([]string{`&ListResponse{`, `Leases:` + repeatedStringForLeases + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Resource) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Resource{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Type:` + fmt.Sprintf("%v", this.Type) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *AddResourceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&AddResourceRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Resource:` + strings.Replace(strings.Replace(this.Resource.String(), "Resource", "Resource", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteResourceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteResourceRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Resource:` + strings.Replace(strings.Replace(this.Resource.String(), "Resource", "Resource", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListResourcesRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListResourcesRequest{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListResourcesResponse) String() string { if this == nil { return "nil" } repeatedStringForResources := "[]Resource{" for _, f := range this.Resources { repeatedStringForResources += strings.Replace(strings.Replace(f.String(), "Resource", "Resource", 1), `&`, ``, 1) + "," } repeatedStringForResources += "}" s := strings.Join([]string{`&ListResourcesResponse{`, `Resources:` + repeatedStringForResources + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringLeases(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Lease) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Lease: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Lease: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthLeases } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthLeases } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthLeases } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthLeases } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthLeases } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthLeases } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthLeases } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthLeases } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if m.Lease == nil { m.Lease = &Lease{} } if err := m.Lease.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Sync", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Sync = bool(v != 0) default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leases", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.Leases = append(m.Leases, &Lease{}) if err := m.Leases[len(m.Leases)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Resource) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Resource: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Resource: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *AddResourceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: AddResourceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AddResourceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteResourceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteResourceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteResourceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListResourcesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListResourcesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListResourcesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListResourcesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListResourcesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListResourcesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowLeases } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthLeases } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthLeases } if postIndex > l { return io.ErrUnexpectedEOF } m.Resources = append(m.Resources, Resource{}) if err := m.Resources[len(m.Resources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipLeases(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthLeases } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipLeases(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowLeases } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowLeases } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowLeases } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthLeases } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupLeases } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthLeases } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthLeases = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowLeases = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupLeases = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/leases/v1/leases.proto000066400000000000000000000064061416535272200224300ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.leases.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/services/leases/v1;leases"; // Leases service manages resources leases within the metadata store. service Leases { // Create creates a new lease for managing changes to metadata. A lease // can be used to protect objects from being removed. rpc Create(CreateRequest) returns (CreateResponse); // Delete deletes the lease and makes any unreferenced objects created // during the lease eligible for garbage collection if not referenced // or retained by other resources during the lease. rpc Delete(DeleteRequest) returns (google.protobuf.Empty); // List lists all active leases, returning the full list of // leases and optionally including the referenced resources. rpc List(ListRequest) returns (ListResponse); // AddResource references the resource by the provided lease. rpc AddResource(AddResourceRequest) returns (google.protobuf.Empty); // DeleteResource dereferences the resource by the provided lease. rpc DeleteResource(DeleteResourceRequest) returns (google.protobuf.Empty); // ListResources lists all the resources referenced by the lease. rpc ListResources(ListResourcesRequest) returns (ListResourcesResponse); } // Lease is an object which retains resources while it exists. message Lease { string id = 1; google.protobuf.Timestamp created_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; map labels = 3; } message CreateRequest { // ID is used to identity the lease, when the id is not set the service // generates a random identifier for the lease. string id = 1; map labels = 3; } message CreateResponse { Lease lease = 1; } message DeleteRequest { string id = 1; // Sync indicates that the delete and cleanup should be done // synchronously before returning to the caller // // Default is false bool sync = 2; } message ListRequest { repeated string filters = 1; } message ListResponse { repeated Lease leases = 1; } message Resource { string id = 1; // For snapshotter resource, there are many snapshotter types here, like // overlayfs, devmapper etc. The type will be formatted with type, // like "snapshotter/overlayfs". string type = 2; } message AddResourceRequest { string id = 1; Resource resource = 2 [(gogoproto.nullable) = false]; } message DeleteResourceRequest { string id = 1; Resource resource = 2 [(gogoproto.nullable) = false]; } message ListResourcesRequest { string id = 1; } message ListResourcesResponse { repeated Resource resources = 1 [(gogoproto.nullable) = false]; } containerd-1.5.9/api/services/namespaces/000077500000000000000000000000001416535272200203765ustar00rootroot00000000000000containerd-1.5.9/api/services/namespaces/v1/000077500000000000000000000000001416535272200207245ustar00rootroot00000000000000containerd-1.5.9/api/services/namespaces/v1/namespace.pb.go000066400000000000000000002070261416535272200236160ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto package namespaces import ( context "context" fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" types "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Namespace struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Labels provides an area to include arbitrary data on namespaces. // // The combined size of a key/value pair cannot exceed 4096 bytes. // // Note that to add a new value to this field, read the existing set and // include the entire result in the update call. 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Namespace) Reset() { *m = Namespace{} } func (*Namespace) ProtoMessage() {} func (*Namespace) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{0} } func (m *Namespace) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Namespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Namespace.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Namespace) XXX_Merge(src proto.Message) { xxx_messageInfo_Namespace.Merge(m, src) } func (m *Namespace) XXX_Size() int { return m.Size() } func (m *Namespace) XXX_DiscardUnknown() { xxx_messageInfo_Namespace.DiscardUnknown(m) } var xxx_messageInfo_Namespace proto.InternalMessageInfo type GetNamespaceRequest struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetNamespaceRequest) Reset() { *m = GetNamespaceRequest{} } func (*GetNamespaceRequest) ProtoMessage() {} func (*GetNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{1} } func (m *GetNamespaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetNamespaceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetNamespaceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetNamespaceRequest.Merge(m, src) } func (m *GetNamespaceRequest) XXX_Size() int { return m.Size() } func (m *GetNamespaceRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetNamespaceRequest.DiscardUnknown(m) } var xxx_messageInfo_GetNamespaceRequest proto.InternalMessageInfo type GetNamespaceResponse struct { Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetNamespaceResponse) Reset() { *m = GetNamespaceResponse{} } func (*GetNamespaceResponse) ProtoMessage() {} func (*GetNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{2} } func (m *GetNamespaceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetNamespaceResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetNamespaceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetNamespaceResponse.Merge(m, src) } func (m *GetNamespaceResponse) XXX_Size() int { return m.Size() } func (m *GetNamespaceResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetNamespaceResponse.DiscardUnknown(m) } var xxx_messageInfo_GetNamespaceResponse proto.InternalMessageInfo type ListNamespacesRequest struct { Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListNamespacesRequest) Reset() { *m = ListNamespacesRequest{} } func (*ListNamespacesRequest) ProtoMessage() {} func (*ListNamespacesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{3} } func (m *ListNamespacesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListNamespacesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListNamespacesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListNamespacesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListNamespacesRequest.Merge(m, src) } func (m *ListNamespacesRequest) XXX_Size() int { return m.Size() } func (m *ListNamespacesRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListNamespacesRequest.DiscardUnknown(m) } var xxx_messageInfo_ListNamespacesRequest proto.InternalMessageInfo type ListNamespacesResponse struct { Namespaces []Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListNamespacesResponse) Reset() { *m = ListNamespacesResponse{} } func (*ListNamespacesResponse) ProtoMessage() {} func (*ListNamespacesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{4} } func (m *ListNamespacesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListNamespacesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListNamespacesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListNamespacesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListNamespacesResponse.Merge(m, src) } func (m *ListNamespacesResponse) XXX_Size() int { return m.Size() } func (m *ListNamespacesResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListNamespacesResponse.DiscardUnknown(m) } var xxx_messageInfo_ListNamespacesResponse proto.InternalMessageInfo type CreateNamespaceRequest struct { Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateNamespaceRequest) Reset() { *m = CreateNamespaceRequest{} } func (*CreateNamespaceRequest) ProtoMessage() {} func (*CreateNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{5} } func (m *CreateNamespaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateNamespaceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateNamespaceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateNamespaceRequest.Merge(m, src) } func (m *CreateNamespaceRequest) XXX_Size() int { return m.Size() } func (m *CreateNamespaceRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateNamespaceRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateNamespaceRequest proto.InternalMessageInfo type CreateNamespaceResponse struct { Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateNamespaceResponse) Reset() { *m = CreateNamespaceResponse{} } func (*CreateNamespaceResponse) ProtoMessage() {} func (*CreateNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{6} } func (m *CreateNamespaceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateNamespaceResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateNamespaceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateNamespaceResponse.Merge(m, src) } func (m *CreateNamespaceResponse) XXX_Size() int { return m.Size() } func (m *CreateNamespaceResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateNamespaceResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateNamespaceResponse proto.InternalMessageInfo // UpdateNamespaceRequest updates the metadata for a namespace. // // The operation should follow semantics described in // https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, // unless otherwise qualified. type UpdateNamespaceRequest struct { // Namespace provides the target value, as declared by the mask, for the update. // // The namespace field must be set. Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // For the most part, this applies only to selectively updating labels on // the namespace. While field masks are typically limited to ascii alphas // and digits, we just take everything after the "labels." as the map key. UpdateMask *types.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateNamespaceRequest) Reset() { *m = UpdateNamespaceRequest{} } func (*UpdateNamespaceRequest) ProtoMessage() {} func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{7} } func (m *UpdateNamespaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateNamespaceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateNamespaceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateNamespaceRequest.Merge(m, src) } func (m *UpdateNamespaceRequest) XXX_Size() int { return m.Size() } func (m *UpdateNamespaceRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateNamespaceRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateNamespaceRequest proto.InternalMessageInfo type UpdateNamespaceResponse struct { Namespace Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateNamespaceResponse) Reset() { *m = UpdateNamespaceResponse{} } func (*UpdateNamespaceResponse) ProtoMessage() {} func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{8} } func (m *UpdateNamespaceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateNamespaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateNamespaceResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateNamespaceResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateNamespaceResponse.Merge(m, src) } func (m *UpdateNamespaceResponse) XXX_Size() int { return m.Size() } func (m *UpdateNamespaceResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateNamespaceResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateNamespaceResponse proto.InternalMessageInfo type DeleteNamespaceRequest struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteNamespaceRequest) Reset() { *m = DeleteNamespaceRequest{} } func (*DeleteNamespaceRequest) ProtoMessage() {} func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor_8c41761eaeea4fd3, []int{9} } func (m *DeleteNamespaceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteNamespaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteNamespaceRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteNamespaceRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteNamespaceRequest.Merge(m, src) } func (m *DeleteNamespaceRequest) XXX_Size() int { return m.Size() } func (m *DeleteNamespaceRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteNamespaceRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteNamespaceRequest proto.InternalMessageInfo func init() { proto.RegisterType((*Namespace)(nil), "containerd.services.namespaces.v1.Namespace") proto.RegisterMapType((map[string]string)(nil), "containerd.services.namespaces.v1.Namespace.LabelsEntry") proto.RegisterType((*GetNamespaceRequest)(nil), "containerd.services.namespaces.v1.GetNamespaceRequest") proto.RegisterType((*GetNamespaceResponse)(nil), "containerd.services.namespaces.v1.GetNamespaceResponse") proto.RegisterType((*ListNamespacesRequest)(nil), "containerd.services.namespaces.v1.ListNamespacesRequest") proto.RegisterType((*ListNamespacesResponse)(nil), "containerd.services.namespaces.v1.ListNamespacesResponse") proto.RegisterType((*CreateNamespaceRequest)(nil), "containerd.services.namespaces.v1.CreateNamespaceRequest") proto.RegisterType((*CreateNamespaceResponse)(nil), "containerd.services.namespaces.v1.CreateNamespaceResponse") proto.RegisterType((*UpdateNamespaceRequest)(nil), "containerd.services.namespaces.v1.UpdateNamespaceRequest") proto.RegisterType((*UpdateNamespaceResponse)(nil), "containerd.services.namespaces.v1.UpdateNamespaceResponse") proto.RegisterType((*DeleteNamespaceRequest)(nil), "containerd.services.namespaces.v1.DeleteNamespaceRequest") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", fileDescriptor_8c41761eaeea4fd3) } var fileDescriptor_8c41761eaeea4fd3 = []byte{ // 551 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x6e, 0xd3, 0x4c, 0x14, 0xcd, 0x24, 0xf9, 0x2c, 0xe5, 0x7a, 0xf3, 0x69, 0x08, 0x26, 0x32, 0x92, 0x09, 0x5e, 0x15, 0xa9, 0x1a, 0xab, 0x41, 0x82, 0xfe, 0xec, 0x0a, 0x6d, 0x17, 0x14, 0x84, 0x2c, 0x21, 0x21, 0x58, 0x80, 0x93, 0x4c, 0x5c, 0x13, 0xc7, 0x36, 0x9e, 0xb1, 0xa5, 0x88, 0x05, 0xbc, 0x0d, 0x1b, 0x1e, 0x24, 0x4b, 0x96, 0xac, 0x50, 0x9b, 0x27, 0x41, 0x33, 0x76, 0xe2, 0xd0, 0x18, 0xe1, 0x06, 0xca, 0xee, 0x5e, 0x7b, 0xce, 0x3d, 0x67, 0xae, 0xce, 0xb1, 0xe1, 0x89, 0xeb, 0xf1, 0xb3, 0xa4, 0x4f, 0x06, 0xe1, 0xc4, 0x1a, 0x84, 0x01, 0x77, 0xbc, 0x80, 0xc6, 0xc3, 0xd5, 0xd2, 0x89, 0x3c, 0x8b, 0xd1, 0x38, 0xf5, 0x06, 0x94, 0x59, 0x81, 0x33, 0xa1, 0x2c, 0x72, 0x44, 0x99, 0xee, 0x14, 0x1d, 0x89, 0xe2, 0x90, 0x87, 0xf8, 0x6e, 0x01, 0x23, 0x0b, 0x08, 0x29, 0x20, 0x24, 0xdd, 0xd1, 0xdb, 0x6e, 0xe8, 0x86, 0xf2, 0xb4, 0x25, 0xaa, 0x0c, 0xa8, 0xdf, 0x76, 0xc3, 0xd0, 0xf5, 0xa9, 0x25, 0xbb, 0x7e, 0x32, 0xb2, 0xe8, 0x24, 0xe2, 0xd3, 0xfc, 0x65, 0xf7, 0xf2, 0xcb, 0x91, 0x47, 0xfd, 0xe1, 0x9b, 0x89, 0xc3, 0xc6, 0xd9, 0x09, 0xf3, 0x0b, 0x82, 0xd6, 0xb3, 0x05, 0x0d, 0xc6, 0xd0, 0x14, 0x9c, 0x1d, 0xd4, 0x45, 0x5b, 0x2d, 0x5b, 0xd6, 0xf8, 0x39, 0x28, 0xbe, 0xd3, 0xa7, 0x3e, 0xeb, 0xd4, 0xbb, 0x8d, 0x2d, 0xb5, 0xb7, 0x4b, 0x7e, 0x2b, 0x95, 0x2c, 0x27, 0x92, 0x53, 0x09, 0x3d, 0x0a, 0x78, 0x3c, 0xb5, 0xf3, 0x39, 0xfa, 0x1e, 0xa8, 0x2b, 0x8f, 0xf1, 0xff, 0xd0, 0x18, 0xd3, 0x69, 0xce, 0x29, 0x4a, 0xdc, 0x86, 0xff, 0x52, 0xc7, 0x4f, 0x68, 0xa7, 0x2e, 0x9f, 0x65, 0xcd, 0x7e, 0x7d, 0x17, 0x99, 0xf7, 0xe0, 0xc6, 0x09, 0xe5, 0xcb, 0xf1, 0x36, 0x7d, 0x9f, 0x50, 0xc6, 0xcb, 0x74, 0x9b, 0x67, 0xd0, 0xfe, 0xf9, 0x28, 0x8b, 0xc2, 0x80, 0x89, 0xfb, 0xb4, 0x96, 0x62, 0x25, 0x40, 0xed, 0x6d, 0x5f, 0xe5, 0x4a, 0x87, 0xcd, 0xd9, 0xf7, 0x3b, 0x35, 0xbb, 0x18, 0x62, 0x5a, 0x70, 0xf3, 0xd4, 0x63, 0x05, 0x15, 0x5b, 0xc8, 0xd2, 0x40, 0x19, 0x79, 0x3e, 0xa7, 0x71, 0x2e, 0x2c, 0xef, 0x4c, 0x1f, 0xb4, 0xcb, 0x80, 0x5c, 0x9c, 0x0d, 0x50, 0xd0, 0x76, 0x90, 0x5c, 0xf8, 0x26, 0xea, 0x56, 0xa6, 0x98, 0xef, 0x40, 0x7b, 0x14, 0x53, 0x87, 0xd3, 0xb5, 0xb5, 0xfd, 0xfd, 0x55, 0x8c, 0xe1, 0xd6, 0x1a, 0xd7, 0xb5, 0xed, 0xfd, 0x33, 0x02, 0xed, 0x45, 0x34, 0xfc, 0x27, 0x37, 0xc3, 0x07, 0xa0, 0x26, 0x92, 0x4b, 0xa6, 0x47, 0x3a, 0x53, 0xed, 0xe9, 0x24, 0x0b, 0x18, 0x59, 0x04, 0x8c, 0x1c, 0x8b, 0x80, 0x3d, 0x75, 0xd8, 0xd8, 0x86, 0xec, 0xb8, 0xa8, 0xc5, 0x5a, 0xd6, 0x84, 0x5e, 0xdb, 0x5a, 0xb6, 0x41, 0x7b, 0x4c, 0x7d, 0x5a, 0xb2, 0x95, 0x92, 0x98, 0xf4, 0xce, 0x9b, 0x00, 0x85, 0x11, 0x71, 0x0a, 0x8d, 0x13, 0xca, 0xf1, 0x83, 0x0a, 0x12, 0x4a, 0x82, 0xa8, 0x3f, 0xbc, 0x32, 0x2e, 0x5f, 0xc3, 0x07, 0x68, 0x8a, 0x48, 0xe0, 0x2a, 0x5f, 0x97, 0xd2, 0xb0, 0xe9, 0x7b, 0x1b, 0x20, 0x73, 0xf2, 0x8f, 0xa0, 0x64, 0xae, 0xc5, 0x55, 0x86, 0x94, 0x87, 0x49, 0xdf, 0xdf, 0x04, 0x5a, 0x08, 0xc8, 0xfc, 0x51, 0x49, 0x40, 0xb9, 0xe7, 0x2b, 0x09, 0xf8, 0x95, 0x0b, 0x5f, 0x83, 0x92, 0x79, 0xa6, 0x92, 0x80, 0x72, 0x7b, 0xe9, 0xda, 0x5a, 0x1a, 0x8e, 0xc4, 0xbf, 0xe8, 0xf0, 0xed, 0xec, 0xc2, 0xa8, 0x7d, 0xbb, 0x30, 0x6a, 0x9f, 0xe6, 0x06, 0x9a, 0xcd, 0x0d, 0xf4, 0x75, 0x6e, 0xa0, 0xf3, 0xb9, 0x81, 0x5e, 0x1d, 0xff, 0xc1, 0x2f, 0xf4, 0xa0, 0xe8, 0x5e, 0xd6, 0xfa, 0x8a, 0xe4, 0xbc, 0xff, 0x23, 0x00, 0x00, 0xff, 0xff, 0x4f, 0x4a, 0x87, 0xf3, 0x95, 0x07, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // NamespacesClient is the client API for Namespaces service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type NamespacesClient interface { Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*types.Empty, error) } type namespacesClient struct { cc *grpc.ClientConn } func NewNamespacesClient(cc *grpc.ClientConn) NamespacesClient { return &namespacesClient{cc} } func (c *namespacesClient) Get(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) { out := new(GetNamespaceResponse) err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *namespacesClient) List(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) { out := new(ListNamespacesResponse) err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/List", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *namespacesClient) Create(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) { out := new(CreateNamespaceResponse) err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *namespacesClient) Update(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) { out := new(UpdateNamespaceResponse) err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *namespacesClient) Delete(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*types.Empty, error) { out := new(types.Empty) err := c.cc.Invoke(ctx, "/containerd.services.namespaces.v1.Namespaces/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } // NamespacesServer is the server API for Namespaces service. type NamespacesServer interface { Get(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error) List(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error) Create(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error) Update(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) Delete(context.Context, *DeleteNamespaceRequest) (*types.Empty, error) } // UnimplementedNamespacesServer can be embedded to have forward compatible implementations. type UnimplementedNamespacesServer struct { } func (*UnimplementedNamespacesServer) Get(ctx context.Context, req *GetNamespaceRequest) (*GetNamespaceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") } func (*UnimplementedNamespacesServer) List(ctx context.Context, req *ListNamespacesRequest) (*ListNamespacesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedNamespacesServer) Create(ctx context.Context, req *CreateNamespaceRequest) (*CreateNamespaceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") } func (*UnimplementedNamespacesServer) Update(ctx context.Context, req *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedNamespacesServer) Delete(ctx context.Context, req *DeleteNamespaceRequest) (*types.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func RegisterNamespacesServer(s *grpc.Server, srv NamespacesServer) { s.RegisterService(&_Namespaces_serviceDesc, srv) } func _Namespaces_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetNamespaceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(NamespacesServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.namespaces.v1.Namespaces/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(NamespacesServer).Get(ctx, req.(*GetNamespaceRequest)) } return interceptor(ctx, in, info, handler) } func _Namespaces_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListNamespacesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(NamespacesServer).List(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.namespaces.v1.Namespaces/List", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(NamespacesServer).List(ctx, req.(*ListNamespacesRequest)) } return interceptor(ctx, in, info, handler) } func _Namespaces_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateNamespaceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(NamespacesServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.namespaces.v1.Namespaces/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(NamespacesServer).Create(ctx, req.(*CreateNamespaceRequest)) } return interceptor(ctx, in, info, handler) } func _Namespaces_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateNamespaceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(NamespacesServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.namespaces.v1.Namespaces/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(NamespacesServer).Update(ctx, req.(*UpdateNamespaceRequest)) } return interceptor(ctx, in, info, handler) } func _Namespaces_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteNamespaceRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(NamespacesServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.namespaces.v1.Namespaces/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(NamespacesServer).Delete(ctx, req.(*DeleteNamespaceRequest)) } return interceptor(ctx, in, info, handler) } var _Namespaces_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.namespaces.v1.Namespaces", HandlerType: (*NamespacesServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Get", Handler: _Namespaces_Get_Handler, }, { MethodName: "List", Handler: _Namespaces_List_Handler, }, { MethodName: "Create", Handler: _Namespaces_Create_Handler, }, { MethodName: "Update", Handler: _Namespaces_Update_Handler, }, { MethodName: "Delete", Handler: _Namespaces_Delete_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/namespaces/v1/namespace.proto", } func (m *Namespace) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Namespace) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintNamespace(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintNamespace(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintNamespace(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetNamespaceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetNamespaceResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *ListNamespacesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListNamespacesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListNamespacesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filter) > 0 { i -= len(m.Filter) copy(dAtA[i:], m.Filter) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Filter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListNamespacesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListNamespacesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListNamespacesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Namespaces) > 0 { for iNdEx := len(m.Namespaces) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Namespaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *CreateNamespaceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *CreateNamespaceResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateNamespaceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.UpdateMask != nil { { size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } { size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateNamespaceResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateNamespaceResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateNamespaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintNamespace(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *DeleteNamespaceRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteNamespaceRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteNamespaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintNamespace(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintNamespace(dAtA []byte, offset int, v uint64) int { offset -= sovNamespace(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Namespace) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovNamespace(uint64(len(k))) + 1 + len(v) + sovNamespace(uint64(len(v))) n += mapEntrySize + 1 + sovNamespace(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetNamespaceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetNamespaceResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Namespace.Size() n += 1 + l + sovNamespace(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListNamespacesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Filter) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListNamespacesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Namespaces) > 0 { for _, e := range m.Namespaces { l = e.Size() n += 1 + l + sovNamespace(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateNamespaceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Namespace.Size() n += 1 + l + sovNamespace(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateNamespaceResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Namespace.Size() n += 1 + l + sovNamespace(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateNamespaceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Namespace.Size() n += 1 + l + sovNamespace(uint64(l)) if m.UpdateMask != nil { l = m.UpdateMask.Size() n += 1 + l + sovNamespace(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateNamespaceResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Namespace.Size() n += 1 + l + sovNamespace(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteNamespaceRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovNamespace(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovNamespace(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozNamespace(x uint64) (n int) { return sovNamespace(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Namespace) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&Namespace{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetNamespaceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetNamespaceRequest{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetNamespaceResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetNamespaceResponse{`, `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListNamespacesRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListNamespacesRequest{`, `Filter:` + fmt.Sprintf("%v", this.Filter) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListNamespacesResponse) String() string { if this == nil { return "nil" } repeatedStringForNamespaces := "[]Namespace{" for _, f := range this.Namespaces { repeatedStringForNamespaces += strings.Replace(strings.Replace(f.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + "," } repeatedStringForNamespaces += "}" s := strings.Join([]string{`&ListNamespacesResponse{`, `Namespaces:` + repeatedStringForNamespaces + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateNamespaceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateNamespaceRequest{`, `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateNamespaceResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateNamespaceResponse{`, `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateNamespaceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateNamespaceRequest{`, `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types.FieldMask", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateNamespaceResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateNamespaceResponse{`, `Namespace:` + strings.Replace(strings.Replace(this.Namespace.String(), "Namespace", "Namespace", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteNamespaceRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteNamespaceRequest{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringNamespace(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Namespace) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Namespace: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthNamespace } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthNamespace } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthNamespace } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetNamespaceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetNamespaceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetNamespaceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetNamespaceResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListNamespacesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListNamespacesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListNamespacesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Filter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListNamespacesResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListNamespacesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListNamespacesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Namespaces = append(m.Namespaces, Namespace{}) if err := m.Namespaces[len(m.Namespaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateNamespaceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateNamespaceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateNamespaceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateNamespaceResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateNamespaceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateNamespaceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if m.UpdateMask == nil { m.UpdateMask = &types.FieldMask{} } if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateNamespaceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateNamespaceResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateNamespaceResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Namespace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteNamespaceRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteNamespaceRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteNamespaceRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowNamespace } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthNamespace } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthNamespace } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNamespace(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthNamespace } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipNamespace(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowNamespace } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthNamespace } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupNamespace } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthNamespace } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthNamespace = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowNamespace = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupNamespace = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/namespaces/v1/namespace.proto000066400000000000000000000067161416535272200237570ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.namespaces.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/field_mask.proto"; option go_package = "github.com/containerd/containerd/api/services/namespaces/v1;namespaces"; // Namespaces provides the ability to manipulate containerd namespaces. // // All objects in the system are required to be a member of a namespace. If a // namespace is deleted, all objects, including containers, images and // snapshots, will be deleted, as well. // // Unless otherwise noted, operations in containerd apply only to the namespace // supplied per request. // // I hope this goes without saying, but namespaces are themselves NOT // namespaced. service Namespaces { rpc Get(GetNamespaceRequest) returns (GetNamespaceResponse); rpc List(ListNamespacesRequest) returns (ListNamespacesResponse); rpc Create(CreateNamespaceRequest) returns (CreateNamespaceResponse); rpc Update(UpdateNamespaceRequest) returns (UpdateNamespaceResponse); rpc Delete(DeleteNamespaceRequest) returns (google.protobuf.Empty); } message Namespace { string name = 1; // Labels provides an area to include arbitrary data on namespaces. // // The combined size of a key/value pair cannot exceed 4096 bytes. // // Note that to add a new value to this field, read the existing set and // include the entire result in the update call. map labels = 2; } message GetNamespaceRequest { string name = 1; } message GetNamespaceResponse { Namespace namespace = 1 [(gogoproto.nullable) = false]; } message ListNamespacesRequest { string filter = 1; } message ListNamespacesResponse { repeated Namespace namespaces = 1 [(gogoproto.nullable) = false]; } message CreateNamespaceRequest { Namespace namespace = 1 [(gogoproto.nullable) = false]; } message CreateNamespaceResponse { Namespace namespace = 1 [(gogoproto.nullable) = false]; } // UpdateNamespaceRequest updates the metadata for a namespace. // // The operation should follow semantics described in // https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/field-mask, // unless otherwise qualified. message UpdateNamespaceRequest { // Namespace provides the target value, as declared by the mask, for the update. // // The namespace field must be set. Namespace namespace = 1 [(gogoproto.nullable) = false]; // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // For the most part, this applies only to selectively updating labels on // the namespace. While field masks are typically limited to ascii alphas // and digits, we just take everything after the "labels." as the map key. google.protobuf.FieldMask update_mask = 2; } message UpdateNamespaceResponse { Namespace namespace = 1 [(gogoproto.nullable) = false]; } message DeleteNamespaceRequest { string name = 1; } containerd-1.5.9/api/services/snapshots/000077500000000000000000000000001416535272200203015ustar00rootroot00000000000000containerd-1.5.9/api/services/snapshots/v1/000077500000000000000000000000001416535272200206275ustar00rootroot00000000000000containerd-1.5.9/api/services/snapshots/v1/snapshots.pb.go000066400000000000000000004432231416535272200236100ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto package snapshots import ( context "context" fmt "fmt" types "github.com/containerd/containerd/api/types" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Kind int32 const ( KindUnknown Kind = 0 KindView Kind = 1 KindActive Kind = 2 KindCommitted Kind = 3 ) var Kind_name = map[int32]string{ 0: "UNKNOWN", 1: "VIEW", 2: "ACTIVE", 3: "COMMITTED", } var Kind_value = map[string]int32{ "UNKNOWN": 0, "VIEW": 1, "ACTIVE": 2, "COMMITTED": 3, } func (x Kind) String() string { return proto.EnumName(Kind_name, int32(x)) } func (Kind) EnumDescriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{0} } type PrepareSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Parent string `protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrepareSnapshotRequest) Reset() { *m = PrepareSnapshotRequest{} } func (*PrepareSnapshotRequest) ProtoMessage() {} func (*PrepareSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{0} } func (m *PrepareSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrepareSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrepareSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PrepareSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PrepareSnapshotRequest.Merge(m, src) } func (m *PrepareSnapshotRequest) XXX_Size() int { return m.Size() } func (m *PrepareSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_PrepareSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_PrepareSnapshotRequest proto.InternalMessageInfo type PrepareSnapshotResponse struct { Mounts []*types.Mount `protobuf:"bytes,1,rep,name=mounts,proto3" json:"mounts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrepareSnapshotResponse) Reset() { *m = PrepareSnapshotResponse{} } func (*PrepareSnapshotResponse) ProtoMessage() {} func (*PrepareSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{1} } func (m *PrepareSnapshotResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrepareSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrepareSnapshotResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PrepareSnapshotResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PrepareSnapshotResponse.Merge(m, src) } func (m *PrepareSnapshotResponse) XXX_Size() int { return m.Size() } func (m *PrepareSnapshotResponse) XXX_DiscardUnknown() { xxx_messageInfo_PrepareSnapshotResponse.DiscardUnknown(m) } var xxx_messageInfo_PrepareSnapshotResponse proto.InternalMessageInfo type ViewSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Parent string `protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ViewSnapshotRequest) Reset() { *m = ViewSnapshotRequest{} } func (*ViewSnapshotRequest) ProtoMessage() {} func (*ViewSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{2} } func (m *ViewSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ViewSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ViewSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ViewSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ViewSnapshotRequest.Merge(m, src) } func (m *ViewSnapshotRequest) XXX_Size() int { return m.Size() } func (m *ViewSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_ViewSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_ViewSnapshotRequest proto.InternalMessageInfo type ViewSnapshotResponse struct { Mounts []*types.Mount `protobuf:"bytes,1,rep,name=mounts,proto3" json:"mounts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ViewSnapshotResponse) Reset() { *m = ViewSnapshotResponse{} } func (*ViewSnapshotResponse) ProtoMessage() {} func (*ViewSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{3} } func (m *ViewSnapshotResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ViewSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ViewSnapshotResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ViewSnapshotResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ViewSnapshotResponse.Merge(m, src) } func (m *ViewSnapshotResponse) XXX_Size() int { return m.Size() } func (m *ViewSnapshotResponse) XXX_DiscardUnknown() { xxx_messageInfo_ViewSnapshotResponse.DiscardUnknown(m) } var xxx_messageInfo_ViewSnapshotResponse proto.InternalMessageInfo type MountsRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MountsRequest) Reset() { *m = MountsRequest{} } func (*MountsRequest) ProtoMessage() {} func (*MountsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{4} } func (m *MountsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MountsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MountsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *MountsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MountsRequest.Merge(m, src) } func (m *MountsRequest) XXX_Size() int { return m.Size() } func (m *MountsRequest) XXX_DiscardUnknown() { xxx_messageInfo_MountsRequest.DiscardUnknown(m) } var xxx_messageInfo_MountsRequest proto.InternalMessageInfo type MountsResponse struct { Mounts []*types.Mount `protobuf:"bytes,1,rep,name=mounts,proto3" json:"mounts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MountsResponse) Reset() { *m = MountsResponse{} } func (*MountsResponse) ProtoMessage() {} func (*MountsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{5} } func (m *MountsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MountsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MountsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *MountsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MountsResponse.Merge(m, src) } func (m *MountsResponse) XXX_Size() int { return m.Size() } func (m *MountsResponse) XXX_DiscardUnknown() { xxx_messageInfo_MountsResponse.DiscardUnknown(m) } var xxx_messageInfo_MountsResponse proto.InternalMessageInfo type RemoveSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveSnapshotRequest) Reset() { *m = RemoveSnapshotRequest{} } func (*RemoveSnapshotRequest) ProtoMessage() {} func (*RemoveSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{6} } func (m *RemoveSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *RemoveSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveSnapshotRequest.Merge(m, src) } func (m *RemoveSnapshotRequest) XXX_Size() int { return m.Size() } func (m *RemoveSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_RemoveSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_RemoveSnapshotRequest proto.InternalMessageInfo type CommitSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` Key string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitSnapshotRequest) Reset() { *m = CommitSnapshotRequest{} } func (*CommitSnapshotRequest) ProtoMessage() {} func (*CommitSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{7} } func (m *CommitSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CommitSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitSnapshotRequest.Merge(m, src) } func (m *CommitSnapshotRequest) XXX_Size() int { return m.Size() } func (m *CommitSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_CommitSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_CommitSnapshotRequest proto.InternalMessageInfo type StatSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatSnapshotRequest) Reset() { *m = StatSnapshotRequest{} } func (*StatSnapshotRequest) ProtoMessage() {} func (*StatSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{8} } func (m *StatSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StatSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StatSnapshotRequest.Merge(m, src) } func (m *StatSnapshotRequest) XXX_Size() int { return m.Size() } func (m *StatSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_StatSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_StatSnapshotRequest proto.InternalMessageInfo type Info struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Parent string `protobuf:"bytes,2,opt,name=parent,proto3" json:"parent,omitempty"` Kind Kind `protobuf:"varint,3,opt,name=kind,proto3,enum=containerd.services.snapshots.v1.Kind" json:"kind,omitempty"` // CreatedAt provides the time at which the snapshot was created. CreatedAt time.Time `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"` // UpdatedAt provides the time the info was last updated. UpdatedAt time.Time `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"` // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Info) Reset() { *m = Info{} } func (*Info) ProtoMessage() {} func (*Info) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{9} } func (m *Info) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Info) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Info.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Info) XXX_Merge(src proto.Message) { xxx_messageInfo_Info.Merge(m, src) } func (m *Info) XXX_Size() int { return m.Size() } func (m *Info) XXX_DiscardUnknown() { xxx_messageInfo_Info.DiscardUnknown(m) } var xxx_messageInfo_Info proto.InternalMessageInfo type StatSnapshotResponse struct { Info Info `protobuf:"bytes,1,opt,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatSnapshotResponse) Reset() { *m = StatSnapshotResponse{} } func (*StatSnapshotResponse) ProtoMessage() {} func (*StatSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{10} } func (m *StatSnapshotResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatSnapshotResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StatSnapshotResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StatSnapshotResponse.Merge(m, src) } func (m *StatSnapshotResponse) XXX_Size() int { return m.Size() } func (m *StatSnapshotResponse) XXX_DiscardUnknown() { xxx_messageInfo_StatSnapshotResponse.DiscardUnknown(m) } var xxx_messageInfo_StatSnapshotResponse proto.InternalMessageInfo type UpdateSnapshotRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Info Info `protobuf:"bytes,2,opt,name=info,proto3" json:"info"` // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // In info, Name, Parent, Kind, Created are immutable, // other field may be updated using this mask. // If no mask is provided, all mutable field are updated. UpdateMask *types1.FieldMask `protobuf:"bytes,3,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateSnapshotRequest) Reset() { *m = UpdateSnapshotRequest{} } func (*UpdateSnapshotRequest) ProtoMessage() {} func (*UpdateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{11} } func (m *UpdateSnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateSnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateSnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateSnapshotRequest.Merge(m, src) } func (m *UpdateSnapshotRequest) XXX_Size() int { return m.Size() } func (m *UpdateSnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateSnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateSnapshotRequest proto.InternalMessageInfo type UpdateSnapshotResponse struct { Info Info `protobuf:"bytes,1,opt,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateSnapshotResponse) Reset() { *m = UpdateSnapshotResponse{} } func (*UpdateSnapshotResponse) ProtoMessage() {} func (*UpdateSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{12} } func (m *UpdateSnapshotResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateSnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateSnapshotResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateSnapshotResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateSnapshotResponse.Merge(m, src) } func (m *UpdateSnapshotResponse) XXX_Size() int { return m.Size() } func (m *UpdateSnapshotResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateSnapshotResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateSnapshotResponse proto.InternalMessageInfo type ListSnapshotsRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, images that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. Filters []string `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListSnapshotsRequest) Reset() { *m = ListSnapshotsRequest{} } func (*ListSnapshotsRequest) ProtoMessage() {} func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{13} } func (m *ListSnapshotsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListSnapshotsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListSnapshotsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListSnapshotsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListSnapshotsRequest.Merge(m, src) } func (m *ListSnapshotsRequest) XXX_Size() int { return m.Size() } func (m *ListSnapshotsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListSnapshotsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListSnapshotsRequest proto.InternalMessageInfo type ListSnapshotsResponse struct { Info []Info `protobuf:"bytes,1,rep,name=info,proto3" json:"info"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListSnapshotsResponse) Reset() { *m = ListSnapshotsResponse{} } func (*ListSnapshotsResponse) ProtoMessage() {} func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{14} } func (m *ListSnapshotsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListSnapshotsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListSnapshotsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListSnapshotsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListSnapshotsResponse.Merge(m, src) } func (m *ListSnapshotsResponse) XXX_Size() int { return m.Size() } func (m *ListSnapshotsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListSnapshotsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListSnapshotsResponse proto.InternalMessageInfo type UsageRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UsageRequest) Reset() { *m = UsageRequest{} } func (*UsageRequest) ProtoMessage() {} func (*UsageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{15} } func (m *UsageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UsageRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UsageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UsageRequest.Merge(m, src) } func (m *UsageRequest) XXX_Size() int { return m.Size() } func (m *UsageRequest) XXX_DiscardUnknown() { xxx_messageInfo_UsageRequest.DiscardUnknown(m) } var xxx_messageInfo_UsageRequest proto.InternalMessageInfo type UsageResponse struct { Size_ int64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"` Inodes int64 `protobuf:"varint,2,opt,name=inodes,proto3" json:"inodes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UsageResponse) Reset() { *m = UsageResponse{} } func (*UsageResponse) ProtoMessage() {} func (*UsageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{16} } func (m *UsageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UsageResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UsageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UsageResponse.Merge(m, src) } func (m *UsageResponse) XXX_Size() int { return m.Size() } func (m *UsageResponse) XXX_DiscardUnknown() { xxx_messageInfo_UsageResponse.DiscardUnknown(m) } var xxx_messageInfo_UsageResponse proto.InternalMessageInfo type CleanupRequest struct { Snapshotter string `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CleanupRequest) Reset() { *m = CleanupRequest{} } func (*CleanupRequest) ProtoMessage() {} func (*CleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cfc0ddf12791f168, []int{17} } func (m *CleanupRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CleanupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CleanupRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CleanupRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CleanupRequest.Merge(m, src) } func (m *CleanupRequest) XXX_Size() int { return m.Size() } func (m *CleanupRequest) XXX_DiscardUnknown() { xxx_messageInfo_CleanupRequest.DiscardUnknown(m) } var xxx_messageInfo_CleanupRequest proto.InternalMessageInfo func init() { proto.RegisterEnum("containerd.services.snapshots.v1.Kind", Kind_name, Kind_value) proto.RegisterType((*PrepareSnapshotRequest)(nil), "containerd.services.snapshots.v1.PrepareSnapshotRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.snapshots.v1.PrepareSnapshotRequest.LabelsEntry") proto.RegisterType((*PrepareSnapshotResponse)(nil), "containerd.services.snapshots.v1.PrepareSnapshotResponse") proto.RegisterType((*ViewSnapshotRequest)(nil), "containerd.services.snapshots.v1.ViewSnapshotRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.snapshots.v1.ViewSnapshotRequest.LabelsEntry") proto.RegisterType((*ViewSnapshotResponse)(nil), "containerd.services.snapshots.v1.ViewSnapshotResponse") proto.RegisterType((*MountsRequest)(nil), "containerd.services.snapshots.v1.MountsRequest") proto.RegisterType((*MountsResponse)(nil), "containerd.services.snapshots.v1.MountsResponse") proto.RegisterType((*RemoveSnapshotRequest)(nil), "containerd.services.snapshots.v1.RemoveSnapshotRequest") proto.RegisterType((*CommitSnapshotRequest)(nil), "containerd.services.snapshots.v1.CommitSnapshotRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.snapshots.v1.CommitSnapshotRequest.LabelsEntry") proto.RegisterType((*StatSnapshotRequest)(nil), "containerd.services.snapshots.v1.StatSnapshotRequest") proto.RegisterType((*Info)(nil), "containerd.services.snapshots.v1.Info") proto.RegisterMapType((map[string]string)(nil), "containerd.services.snapshots.v1.Info.LabelsEntry") proto.RegisterType((*StatSnapshotResponse)(nil), "containerd.services.snapshots.v1.StatSnapshotResponse") proto.RegisterType((*UpdateSnapshotRequest)(nil), "containerd.services.snapshots.v1.UpdateSnapshotRequest") proto.RegisterType((*UpdateSnapshotResponse)(nil), "containerd.services.snapshots.v1.UpdateSnapshotResponse") proto.RegisterType((*ListSnapshotsRequest)(nil), "containerd.services.snapshots.v1.ListSnapshotsRequest") proto.RegisterType((*ListSnapshotsResponse)(nil), "containerd.services.snapshots.v1.ListSnapshotsResponse") proto.RegisterType((*UsageRequest)(nil), "containerd.services.snapshots.v1.UsageRequest") proto.RegisterType((*UsageResponse)(nil), "containerd.services.snapshots.v1.UsageResponse") proto.RegisterType((*CleanupRequest)(nil), "containerd.services.snapshots.v1.CleanupRequest") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto", fileDescriptor_cfc0ddf12791f168) } var fileDescriptor_cfc0ddf12791f168 = []byte{ // 1047 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4f, 0x6f, 0x1b, 0x45, 0x14, 0xf7, 0xda, 0x5b, 0x27, 0x79, 0x4e, 0x82, 0x99, 0x3a, 0xae, 0xb5, 0x20, 0x67, 0xe5, 0x03, 0x8a, 0x38, 0xec, 0xb6, 0x46, 0xb4, 0x69, 0x73, 0xc1, 0x71, 0x0c, 0x72, 0xd2, 0xa4, 0x68, 0xf3, 0xa7, 0x4d, 0x41, 0x54, 0x1b, 0x7b, 0xec, 0xac, 0xec, 0xfd, 0x83, 0x67, 0xec, 0xca, 0x20, 0x21, 0x8e, 0x55, 0x4e, 0x7c, 0x81, 0x9c, 0xe0, 0x43, 0x20, 0x3e, 0x41, 0x8e, 0x48, 0x5c, 0x38, 0x01, 0xcd, 0x97, 0xe0, 0x84, 0x40, 0x33, 0x3b, 0xeb, 0x7f, 0x71, 0xe5, 0xb5, 0x6b, 0x6e, 0x33, 0x3b, 0xf3, 0xde, 0xfb, 0xbd, 0xdf, 0x9b, 0xf7, 0x9b, 0x59, 0xd8, 0xad, 0x5b, 0xf4, 0xbc, 0x7d, 0xa6, 0x55, 0x5c, 0x5b, 0xaf, 0xb8, 0x0e, 0x35, 0x2d, 0x07, 0xb7, 0xaa, 0x83, 0x43, 0xd3, 0xb3, 0x74, 0x82, 0x5b, 0x1d, 0xab, 0x82, 0x89, 0x4e, 0x1c, 0xd3, 0x23, 0xe7, 0x2e, 0x25, 0x7a, 0xe7, 0x5e, 0x7f, 0xa2, 0x79, 0x2d, 0x97, 0xba, 0x48, 0xed, 0x5b, 0x69, 0x81, 0x85, 0xd6, 0xdf, 0xd4, 0xb9, 0xa7, 0xa4, 0xea, 0x6e, 0xdd, 0xe5, 0x9b, 0x75, 0x36, 0xf2, 0xed, 0x94, 0xf7, 0xea, 0xae, 0x5b, 0x6f, 0x62, 0x9d, 0xcf, 0xce, 0xda, 0x35, 0x1d, 0xdb, 0x1e, 0xed, 0x8a, 0x45, 0x75, 0x74, 0xb1, 0x66, 0xe1, 0x66, 0xf5, 0x85, 0x6d, 0x92, 0x86, 0xd8, 0xb1, 0x3e, 0xba, 0x83, 0x5a, 0x36, 0x26, 0xd4, 0xb4, 0x3d, 0xb1, 0xe1, 0x7e, 0xa8, 0x1c, 0x69, 0xd7, 0xc3, 0x44, 0xb7, 0xdd, 0xb6, 0x43, 0x7d, 0xbb, 0xdc, 0x3f, 0x12, 0xa4, 0x3f, 0x6f, 0x61, 0xcf, 0x6c, 0xe1, 0x43, 0x91, 0x85, 0x81, 0xbf, 0x6e, 0x63, 0x42, 0x91, 0x0a, 0x89, 0x20, 0x31, 0x8a, 0x5b, 0x19, 0x49, 0x95, 0x36, 0x96, 0x8c, 0xc1, 0x4f, 0x28, 0x09, 0xb1, 0x06, 0xee, 0x66, 0xa2, 0x7c, 0x85, 0x0d, 0x51, 0x1a, 0xe2, 0xcc, 0x95, 0x43, 0x33, 0x31, 0xfe, 0x51, 0xcc, 0xd0, 0x97, 0x10, 0x6f, 0x9a, 0x67, 0xb8, 0x49, 0x32, 0xb2, 0x1a, 0xdb, 0x48, 0xe4, 0x77, 0xb4, 0x49, 0x3c, 0x6a, 0xe3, 0x51, 0x69, 0x8f, 0xb9, 0x9b, 0x92, 0x43, 0x5b, 0x5d, 0x43, 0xf8, 0x54, 0x1e, 0x42, 0x62, 0xe0, 0x73, 0x00, 0x4b, 0xea, 0xc3, 0x4a, 0xc1, 0xad, 0x8e, 0xd9, 0x6c, 0x63, 0x01, 0xd5, 0x9f, 0x3c, 0x8a, 0x6e, 0x4a, 0xb9, 0x5d, 0xb8, 0x73, 0x23, 0x10, 0xf1, 0x5c, 0x87, 0x60, 0xa4, 0x43, 0x9c, 0x33, 0x45, 0x32, 0x12, 0xc7, 0x7c, 0x67, 0x10, 0x33, 0x67, 0x52, 0xdb, 0x67, 0xeb, 0x86, 0xd8, 0x96, 0xfb, 0x5b, 0x82, 0xdb, 0x27, 0x16, 0x7e, 0xf9, 0x7f, 0x12, 0x79, 0x3a, 0x42, 0x64, 0x61, 0x32, 0x91, 0x63, 0x20, 0xcd, 0x9b, 0xc5, 0xcf, 0x20, 0x35, 0x1c, 0x65, 0x56, 0x0a, 0x8b, 0xb0, 0xc2, 0x3f, 0x90, 0xb7, 0xe0, 0x2e, 0x57, 0x80, 0xd5, 0xc0, 0xc9, 0xac, 0x38, 0xf6, 0x60, 0xcd, 0xc0, 0xb6, 0xdb, 0x99, 0x47, 0x53, 0xb0, 0x73, 0xb1, 0x56, 0x74, 0x6d, 0xdb, 0xa2, 0xd3, 0x7b, 0x43, 0x20, 0x3b, 0xa6, 0x1d, 0x50, 0xce, 0xc7, 0x41, 0x84, 0x58, 0xbf, 0x32, 0x5f, 0x8c, 0x9c, 0x8a, 0xe2, 0xe4, 0x53, 0x31, 0x16, 0xd0, 0xbc, 0xcf, 0x45, 0x19, 0x6e, 0x1f, 0x52, 0x93, 0xce, 0x83, 0xc4, 0x7f, 0xa3, 0x20, 0x97, 0x9d, 0x9a, 0xdb, 0x63, 0x44, 0x1a, 0x60, 0xa4, 0xdf, 0x2d, 0xd1, 0xa1, 0x6e, 0x79, 0x04, 0x72, 0xc3, 0x72, 0xaa, 0x9c, 0xaa, 0xd5, 0xfc, 0x07, 0x93, 0x59, 0xd9, 0xb3, 0x9c, 0xaa, 0xc1, 0x6d, 0x50, 0x11, 0xa0, 0xd2, 0xc2, 0x26, 0xc5, 0xd5, 0x17, 0x26, 0xcd, 0xc8, 0xaa, 0xb4, 0x91, 0xc8, 0x2b, 0x9a, 0xaf, 0xc3, 0x5a, 0xa0, 0xc3, 0xda, 0x51, 0xa0, 0xc3, 0xdb, 0x8b, 0x57, 0x7f, 0xac, 0x47, 0x7e, 0xf8, 0x73, 0x5d, 0x32, 0x96, 0x84, 0x5d, 0x81, 0x32, 0x27, 0x6d, 0xaf, 0x1a, 0x38, 0xb9, 0x35, 0x8d, 0x13, 0x61, 0x57, 0xa0, 0x68, 0xb7, 0x57, 0xdd, 0x38, 0xaf, 0x6e, 0x7e, 0x72, 0x1e, 0x8c, 0xa9, 0x79, 0x17, 0xf3, 0x19, 0xa4, 0x86, 0x8b, 0x29, 0x9a, 0xeb, 0x13, 0x90, 0x2d, 0xa7, 0xe6, 0x72, 0x27, 0x89, 0x30, 0x24, 0x33, 0x70, 0xdb, 0x32, 0xcb, 0xd4, 0xe0, 0x96, 0xb9, 0x9f, 0x25, 0x58, 0x3b, 0xe6, 0xe9, 0x4e, 0x7f, 0x52, 0x82, 0xe8, 0xd1, 0x59, 0xa3, 0xa3, 0x2d, 0x48, 0xf8, 0x5c, 0xf3, 0x0b, 0x97, 0x9f, 0x95, 0x71, 0x45, 0xfa, 0x94, 0xdd, 0xc9, 0xfb, 0x26, 0x69, 0x18, 0xa2, 0xa4, 0x6c, 0x9c, 0x7b, 0x0e, 0xe9, 0x51, 0xe4, 0x73, 0xa3, 0xc5, 0x80, 0xd4, 0x63, 0x8b, 0xf4, 0x08, 0x9f, 0x42, 0x13, 0x33, 0xb0, 0x50, 0xb3, 0x9a, 0x14, 0xb7, 0x48, 0x26, 0xaa, 0xc6, 0x36, 0x96, 0x8c, 0x60, 0x9a, 0x3b, 0x85, 0xb5, 0x11, 0x9f, 0x37, 0xe0, 0xc6, 0x66, 0x84, 0xbb, 0x0d, 0xcb, 0xc7, 0xc4, 0xac, 0xe3, 0xb7, 0xe9, 0xf2, 0x2d, 0x58, 0x11, 0x3e, 0x04, 0x2c, 0x04, 0x32, 0xb1, 0xbe, 0xf1, 0xbb, 0x3d, 0x66, 0xf0, 0x31, 0xeb, 0x76, 0xcb, 0x71, 0xab, 0x98, 0x70, 0xcb, 0x98, 0x21, 0x66, 0xb9, 0x3c, 0xac, 0x16, 0x9b, 0xd8, 0x74, 0xda, 0x5e, 0x68, 0x08, 0x1f, 0xbe, 0x92, 0x40, 0x66, 0x4d, 0x8f, 0xde, 0x87, 0x85, 0xe3, 0x83, 0xbd, 0x83, 0x27, 0x4f, 0x0f, 0x92, 0x11, 0xe5, 0x9d, 0x8b, 0x4b, 0x35, 0xc1, 0x3e, 0x1f, 0x3b, 0x0d, 0xc7, 0x7d, 0xe9, 0xa0, 0x34, 0xc8, 0x27, 0xe5, 0xd2, 0xd3, 0xa4, 0xa4, 0x2c, 0x5f, 0x5c, 0xaa, 0x8b, 0x6c, 0x89, 0x5d, 0x78, 0x48, 0x81, 0x78, 0xa1, 0x78, 0x54, 0x3e, 0x29, 0x25, 0xa3, 0xca, 0xea, 0xc5, 0xa5, 0x0a, 0x6c, 0xa5, 0x50, 0xa1, 0x56, 0x07, 0x23, 0x15, 0x96, 0x8a, 0x4f, 0xf6, 0xf7, 0xcb, 0x47, 0x47, 0xa5, 0x9d, 0x64, 0x4c, 0x79, 0xf7, 0xe2, 0x52, 0x5d, 0x61, 0xcb, 0xbe, 0xf2, 0x52, 0x5c, 0x55, 0x96, 0x5f, 0xfd, 0x98, 0x8d, 0xfc, 0xf2, 0x53, 0x96, 0x23, 0xc8, 0xff, 0xb6, 0x08, 0x4b, 0xbd, 0xba, 0xa0, 0xef, 0x60, 0x41, 0x3c, 0x4c, 0xd0, 0xe6, 0xac, 0x8f, 0x25, 0xe5, 0xe1, 0x0c, 0x96, 0x82, 0xf8, 0x36, 0xc8, 0x3c, 0xc3, 0x8f, 0x67, 0x7a, 0x60, 0x28, 0xf7, 0xa7, 0x35, 0x13, 0x61, 0x1b, 0x10, 0xf7, 0xef, 0x6e, 0xa4, 0x4f, 0xf6, 0x30, 0xf4, 0x54, 0x50, 0xee, 0x86, 0x37, 0x10, 0xc1, 0x4e, 0x21, 0xee, 0x17, 0x03, 0x3d, 0x98, 0xf1, 0xc2, 0x54, 0xd2, 0x37, 0x74, 0xa2, 0xc4, 0x1e, 0xf6, 0xcc, 0xb5, 0xff, 0x80, 0x08, 0xe3, 0x7a, 0xec, 0x53, 0xe3, 0x8d, 0xae, 0xdb, 0x20, 0x33, 0x1d, 0x0e, 0x53, 0x99, 0x31, 0x97, 0x6f, 0x98, 0xca, 0x8c, 0x95, 0xf9, 0x6f, 0x21, 0xee, 0x2b, 0x5d, 0x98, 0x8c, 0xc6, 0xaa, 0xb9, 0xb2, 0x39, 0xbd, 0xa1, 0x08, 0xde, 0x05, 0x99, 0xc9, 0x16, 0x0a, 0x01, 0x7e, 0x9c, 0x64, 0x2a, 0x0f, 0xa6, 0xb6, 0xf3, 0x03, 0xdf, 0x95, 0xd0, 0x39, 0xdc, 0xe2, 0x92, 0x84, 0xb4, 0x10, 0xe8, 0x07, 0xf4, 0x4f, 0xd1, 0x43, 0xef, 0x17, 0x49, 0x1e, 0xc2, 0x82, 0xd0, 0x2f, 0x14, 0xe2, 0x2c, 0x0f, 0x4b, 0xdd, 0x9b, 0x4e, 0xcb, 0xf6, 0x57, 0x57, 0xaf, 0xb3, 0x91, 0xdf, 0x5f, 0x67, 0x23, 0xdf, 0x5f, 0x67, 0xa5, 0xab, 0xeb, 0xac, 0xf4, 0xeb, 0x75, 0x56, 0xfa, 0xeb, 0x3a, 0x2b, 0x3d, 0xdf, 0x99, 0xfd, 0xb7, 0x78, 0xab, 0x37, 0x79, 0x16, 0x39, 0x8b, 0xf3, 0x88, 0x1f, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x20, 0x9c, 0x85, 0x7f, 0x67, 0x0f, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // SnapshotsClient is the client API for Snapshots service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type SnapshotsClient interface { Prepare(ctx context.Context, in *PrepareSnapshotRequest, opts ...grpc.CallOption) (*PrepareSnapshotResponse, error) View(ctx context.Context, in *ViewSnapshotRequest, opts ...grpc.CallOption) (*ViewSnapshotResponse, error) Mounts(ctx context.Context, in *MountsRequest, opts ...grpc.CallOption) (*MountsResponse, error) Commit(ctx context.Context, in *CommitSnapshotRequest, opts ...grpc.CallOption) (*types1.Empty, error) Remove(ctx context.Context, in *RemoveSnapshotRequest, opts ...grpc.CallOption) (*types1.Empty, error) Stat(ctx context.Context, in *StatSnapshotRequest, opts ...grpc.CallOption) (*StatSnapshotResponse, error) Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*UpdateSnapshotResponse, error) List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (Snapshots_ListClient, error) Usage(ctx context.Context, in *UsageRequest, opts ...grpc.CallOption) (*UsageResponse, error) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*types1.Empty, error) } type snapshotsClient struct { cc *grpc.ClientConn } func NewSnapshotsClient(cc *grpc.ClientConn) SnapshotsClient { return &snapshotsClient{cc} } func (c *snapshotsClient) Prepare(ctx context.Context, in *PrepareSnapshotRequest, opts ...grpc.CallOption) (*PrepareSnapshotResponse, error) { out := new(PrepareSnapshotResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Prepare", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) View(ctx context.Context, in *ViewSnapshotRequest, opts ...grpc.CallOption) (*ViewSnapshotResponse, error) { out := new(ViewSnapshotResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/View", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Mounts(ctx context.Context, in *MountsRequest, opts ...grpc.CallOption) (*MountsResponse, error) { out := new(MountsResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Mounts", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Commit(ctx context.Context, in *CommitSnapshotRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Commit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Remove(ctx context.Context, in *RemoveSnapshotRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Remove", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Stat(ctx context.Context, in *StatSnapshotRequest, opts ...grpc.CallOption) (*StatSnapshotResponse, error) { out := new(StatSnapshotResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Stat", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*UpdateSnapshotResponse, error) { out := new(UpdateSnapshotResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (Snapshots_ListClient, error) { stream, err := c.cc.NewStream(ctx, &_Snapshots_serviceDesc.Streams[0], "/containerd.services.snapshots.v1.Snapshots/List", opts...) if err != nil { return nil, err } x := &snapshotsListClient{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 Snapshots_ListClient interface { Recv() (*ListSnapshotsResponse, error) grpc.ClientStream } type snapshotsListClient struct { grpc.ClientStream } func (x *snapshotsListClient) Recv() (*ListSnapshotsResponse, error) { m := new(ListSnapshotsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *snapshotsClient) Usage(ctx context.Context, in *UsageRequest, opts ...grpc.CallOption) (*UsageResponse, error) { out := new(UsageResponse) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Usage", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *snapshotsClient) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Cleanup", in, out, opts...) if err != nil { return nil, err } return out, nil } // SnapshotsServer is the server API for Snapshots service. type SnapshotsServer interface { Prepare(context.Context, *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error) View(context.Context, *ViewSnapshotRequest) (*ViewSnapshotResponse, error) Mounts(context.Context, *MountsRequest) (*MountsResponse, error) Commit(context.Context, *CommitSnapshotRequest) (*types1.Empty, error) Remove(context.Context, *RemoveSnapshotRequest) (*types1.Empty, error) Stat(context.Context, *StatSnapshotRequest) (*StatSnapshotResponse, error) Update(context.Context, *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error) List(*ListSnapshotsRequest, Snapshots_ListServer) error Usage(context.Context, *UsageRequest) (*UsageResponse, error) Cleanup(context.Context, *CleanupRequest) (*types1.Empty, error) } // UnimplementedSnapshotsServer can be embedded to have forward compatible implementations. type UnimplementedSnapshotsServer struct { } func (*UnimplementedSnapshotsServer) Prepare(ctx context.Context, req *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Prepare not implemented") } func (*UnimplementedSnapshotsServer) View(ctx context.Context, req *ViewSnapshotRequest) (*ViewSnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method View not implemented") } func (*UnimplementedSnapshotsServer) Mounts(ctx context.Context, req *MountsRequest) (*MountsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Mounts not implemented") } func (*UnimplementedSnapshotsServer) Commit(ctx context.Context, req *CommitSnapshotRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented") } func (*UnimplementedSnapshotsServer) Remove(ctx context.Context, req *RemoveSnapshotRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Remove not implemented") } func (*UnimplementedSnapshotsServer) Stat(ctx context.Context, req *StatSnapshotRequest) (*StatSnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Stat not implemented") } func (*UnimplementedSnapshotsServer) Update(ctx context.Context, req *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedSnapshotsServer) List(req *ListSnapshotsRequest, srv Snapshots_ListServer) error { return status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedSnapshotsServer) Usage(ctx context.Context, req *UsageRequest) (*UsageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Usage not implemented") } func (*UnimplementedSnapshotsServer) Cleanup(ctx context.Context, req *CleanupRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Cleanup not implemented") } func RegisterSnapshotsServer(s *grpc.Server, srv SnapshotsServer) { s.RegisterService(&_Snapshots_serviceDesc, srv) } func _Snapshots_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PrepareSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Prepare(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Prepare", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Prepare(ctx, req.(*PrepareSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_View_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ViewSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).View(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/View", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).View(ctx, req.(*ViewSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Mounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MountsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Mounts(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Mounts", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Mounts(ctx, req.(*MountsRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CommitSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Commit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Commit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Commit(ctx, req.(*CommitSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Remove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RemoveSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Remove(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Remove", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Remove(ctx, req.(*RemoveSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Stat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StatSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Stat(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Stat", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Stat(ctx, req.(*StatSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateSnapshotRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Update(ctx, req.(*UpdateSnapshotRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_List_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ListSnapshotsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(SnapshotsServer).List(m, &snapshotsListServer{stream}) } type Snapshots_ListServer interface { Send(*ListSnapshotsResponse) error grpc.ServerStream } type snapshotsListServer struct { grpc.ServerStream } func (x *snapshotsListServer) Send(m *ListSnapshotsResponse) error { return x.ServerStream.SendMsg(m) } func _Snapshots_Usage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UsageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Usage(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Usage", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Usage(ctx, req.(*UsageRequest)) } return interceptor(ctx, in, info, handler) } func _Snapshots_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CleanupRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(SnapshotsServer).Cleanup(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.snapshots.v1.Snapshots/Cleanup", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(SnapshotsServer).Cleanup(ctx, req.(*CleanupRequest)) } return interceptor(ctx, in, info, handler) } var _Snapshots_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.snapshots.v1.Snapshots", HandlerType: (*SnapshotsServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Prepare", Handler: _Snapshots_Prepare_Handler, }, { MethodName: "View", Handler: _Snapshots_View_Handler, }, { MethodName: "Mounts", Handler: _Snapshots_Mounts_Handler, }, { MethodName: "Commit", Handler: _Snapshots_Commit_Handler, }, { MethodName: "Remove", Handler: _Snapshots_Remove_Handler, }, { MethodName: "Stat", Handler: _Snapshots_Stat_Handler, }, { MethodName: "Update", Handler: _Snapshots_Update_Handler, }, { MethodName: "Usage", Handler: _Snapshots_Usage_Handler, }, { MethodName: "Cleanup", Handler: _Snapshots_Cleanup_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "List", Handler: _Snapshots_List_Handler, ServerStreams: true, }, }, Metadata: "github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto", } func (m *PrepareSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrepareSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PrepareSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintSnapshots(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintSnapshots(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintSnapshots(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.Parent) > 0 { i -= len(m.Parent) copy(dAtA[i:], m.Parent) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Parent))) i-- dAtA[i] = 0x1a } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PrepareSnapshotResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrepareSnapshotResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PrepareSnapshotResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *ViewSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ViewSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ViewSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintSnapshots(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintSnapshots(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintSnapshots(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.Parent) > 0 { i -= len(m.Parent) copy(dAtA[i:], m.Parent) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Parent))) i-- dAtA[i] = 0x1a } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ViewSnapshotResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ViewSnapshotResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ViewSnapshotResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *MountsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MountsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MountsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *MountsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MountsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MountsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *RemoveSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RemoveSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemoveSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CommitSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CommitSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintSnapshots(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintSnapshots(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintSnapshots(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x1a } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StatSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Info) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Info) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintSnapshots(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintSnapshots(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintSnapshots(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x32 } } n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):]) if err1 != nil { return 0, err1 } i -= n1 i = encodeVarintSnapshots(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x2a n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintSnapshots(dAtA, i, uint64(n2)) i-- dAtA[i] = 0x22 if m.Kind != 0 { i = encodeVarintSnapshots(dAtA, i, uint64(m.Kind)) i-- dAtA[i] = 0x18 } if len(m.Parent) > 0 { i -= len(m.Parent) copy(dAtA[i:], m.Parent) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Parent))) i-- dAtA[i] = 0x12 } if len(m.Name) > 0 { i -= len(m.Name) copy(dAtA[i:], m.Name) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StatSnapshotResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatSnapshotResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatSnapshotResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UpdateSnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateSnapshotRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.UpdateMask != nil { { size, err := m.UpdateMask.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UpdateSnapshotResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateSnapshotResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateSnapshotResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *ListSnapshotsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListSnapshotsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListSnapshotsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListSnapshotsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListSnapshotsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListSnapshotsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Info) > 0 { for iNdEx := len(m.Info) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Info[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintSnapshots(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UsageRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UsageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UsageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0x12 } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UsageResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UsageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UsageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Inodes != 0 { i = encodeVarintSnapshots(dAtA, i, uint64(m.Inodes)) i-- dAtA[i] = 0x10 } if m.Size_ != 0 { i = encodeVarintSnapshots(dAtA, i, uint64(m.Size_)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *CleanupRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CleanupRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CleanupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Snapshotter) > 0 { i -= len(m.Snapshotter) copy(dAtA[i:], m.Snapshotter) i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintSnapshots(dAtA []byte, offset int, v uint64) int { offset -= sovSnapshots(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *PrepareSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Parent) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovSnapshots(uint64(len(k))) + 1 + len(v) + sovSnapshots(uint64(len(v))) n += mapEntrySize + 1 + sovSnapshots(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrepareSnapshotResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovSnapshots(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ViewSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Parent) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovSnapshots(uint64(len(k))) + 1 + len(v) + sovSnapshots(uint64(len(v))) n += mapEntrySize + 1 + sovSnapshots(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ViewSnapshotResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovSnapshots(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MountsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MountsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovSnapshots(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RemoveSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Name) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovSnapshots(uint64(len(k))) + 1 + len(v) + sovSnapshots(uint64(len(v))) n += mapEntrySize + 1 + sovSnapshots(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Info) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Parent) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.Kind != 0 { n += 1 + sovSnapshots(uint64(m.Kind)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt) n += 1 + l + sovSnapshots(uint64(l)) l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt) n += 1 + l + sovSnapshots(uint64(l)) if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovSnapshots(uint64(len(k))) + 1 + len(v) + sovSnapshots(uint64(len(v))) n += mapEntrySize + 1 + sovSnapshots(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatSnapshotResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Info.Size() n += 1 + l + sovSnapshots(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateSnapshotRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = m.Info.Size() n += 1 + l + sovSnapshots(uint64(l)) if m.UpdateMask != nil { l = m.UpdateMask.Size() n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateSnapshotResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = m.Info.Size() n += 1 + l + sovSnapshots(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListSnapshotsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovSnapshots(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListSnapshotsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Info) > 0 { for _, e := range m.Info { l = e.Size() n += 1 + l + sovSnapshots(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UsageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UsageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Size_ != 0 { n += 1 + sovSnapshots(uint64(m.Size_)) } if m.Inodes != 0 { n += 1 + sovSnapshots(uint64(m.Inodes)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CleanupRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Snapshotter) if l > 0 { n += 1 + l + sovSnapshots(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovSnapshots(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozSnapshots(x uint64) (n int) { return sovSnapshots(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *PrepareSnapshotRequest) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&PrepareSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Parent:` + fmt.Sprintf("%v", this.Parent) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *PrepareSnapshotResponse) String() string { if this == nil { return "nil" } repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForMounts += "}" s := strings.Join([]string{`&PrepareSnapshotResponse{`, `Mounts:` + repeatedStringForMounts + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ViewSnapshotRequest) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&ViewSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Parent:` + fmt.Sprintf("%v", this.Parent) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ViewSnapshotResponse) String() string { if this == nil { return "nil" } repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForMounts += "}" s := strings.Join([]string{`&ViewSnapshotResponse{`, `Mounts:` + repeatedStringForMounts + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *MountsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&MountsRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *MountsResponse) String() string { if this == nil { return "nil" } repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForMounts += "}" s := strings.Join([]string{`&MountsResponse{`, `Mounts:` + repeatedStringForMounts + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *RemoveSnapshotRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemoveSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CommitSnapshotRequest) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&CommitSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StatSnapshotRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StatSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Info) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k, _ := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" s := strings.Join([]string{`&Info{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Parent:` + fmt.Sprintf("%v", this.Parent) + `,`, `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, `CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `UpdatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `Labels:` + mapStringForLabels + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StatSnapshotResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StatSnapshotResponse{`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateSnapshotRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateSnapshotRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `UpdateMask:` + strings.Replace(fmt.Sprintf("%v", this.UpdateMask), "FieldMask", "types1.FieldMask", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateSnapshotResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateSnapshotResponse{`, `Info:` + strings.Replace(strings.Replace(this.Info.String(), "Info", "Info", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListSnapshotsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListSnapshotsRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListSnapshotsResponse) String() string { if this == nil { return "nil" } repeatedStringForInfo := "[]Info{" for _, f := range this.Info { repeatedStringForInfo += strings.Replace(strings.Replace(f.String(), "Info", "Info", 1), `&`, ``, 1) + "," } repeatedStringForInfo += "}" s := strings.Join([]string{`&ListSnapshotsResponse{`, `Info:` + repeatedStringForInfo + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UsageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UsageRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UsageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UsageResponse{`, `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, `Inodes:` + fmt.Sprintf("%v", this.Inodes) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CleanupRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CleanupRequest{`, `Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringSnapshots(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *PrepareSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PrepareSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrepareSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Parent = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PrepareSnapshotResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PrepareSnapshotResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrepareSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &types.Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ViewSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ViewSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ViewSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Parent = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ViewSnapshotResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ViewSnapshotResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ViewSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &types.Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *MountsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: MountsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MountsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *MountsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: MountsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MountsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Mounts = append(m.Mounts, &types.Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *RemoveSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: RemoveSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoveSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CommitSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CommitSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Info) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Info: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Info: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Parent = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } m.Kind = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Kind |= Kind(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if m.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthSnapshots } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthSnapshots } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StatSnapshotResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StatSnapshotResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateSnapshotRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateSnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UpdateMask", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if m.UpdateMask == nil { m.UpdateMask = &types1.FieldMask{} } if err := m.UpdateMask.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateSnapshotResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateSnapshotResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListSnapshotsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListSnapshotsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListSnapshotsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListSnapshotsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListSnapshotsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListSnapshotsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Info = append(m.Info, Info{}) if err := m.Info[len(m.Info)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UsageRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UsageRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UsageRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UsageResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UsageResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UsageResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= int64(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Inodes", wireType) } m.Inodes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Inodes |= int64(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CleanupRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSnapshots } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthSnapshots } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthSnapshots } if postIndex > l { return io.ErrUnexpectedEOF } m.Snapshotter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshots(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthSnapshots } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipSnapshots(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshots } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshots } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSnapshots } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthSnapshots } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupSnapshots } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthSnapshots } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthSnapshots = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowSnapshots = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupSnapshots = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/snapshots/v1/snapshots.proto000066400000000000000000000120121416535272200237320ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.snapshots.v1; import weak "gogoproto/gogo.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/field_mask.proto"; import "google/protobuf/timestamp.proto"; import "github.com/containerd/containerd/api/types/mount.proto"; option go_package = "github.com/containerd/containerd/api/services/snapshots/v1;snapshots"; // Snapshot service manages snapshots service Snapshots { rpc Prepare(PrepareSnapshotRequest) returns (PrepareSnapshotResponse); rpc View(ViewSnapshotRequest) returns (ViewSnapshotResponse); rpc Mounts(MountsRequest) returns (MountsResponse); rpc Commit(CommitSnapshotRequest) returns (google.protobuf.Empty); rpc Remove(RemoveSnapshotRequest) returns (google.protobuf.Empty); rpc Stat(StatSnapshotRequest) returns (StatSnapshotResponse); rpc Update(UpdateSnapshotRequest) returns (UpdateSnapshotResponse); rpc List(ListSnapshotsRequest) returns (stream ListSnapshotsResponse); rpc Usage(UsageRequest) returns (UsageResponse); rpc Cleanup(CleanupRequest) returns (google.protobuf.Empty); } message PrepareSnapshotRequest { string snapshotter = 1; string key = 2; string parent = 3; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 4; } message PrepareSnapshotResponse { repeated containerd.types.Mount mounts = 1; } message ViewSnapshotRequest { string snapshotter = 1; string key = 2; string parent = 3; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 4; } message ViewSnapshotResponse { repeated containerd.types.Mount mounts = 1; } message MountsRequest { string snapshotter = 1; string key = 2; } message MountsResponse { repeated containerd.types.Mount mounts = 1; } message RemoveSnapshotRequest { string snapshotter = 1; string key = 2; } message CommitSnapshotRequest { string snapshotter = 1; string name = 2; string key = 3; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 4; } message StatSnapshotRequest { string snapshotter = 1; string key = 2; } enum Kind { option (gogoproto.goproto_enum_prefix) = false; option (gogoproto.enum_customname) = "Kind"; UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "KindUnknown"]; VIEW = 1 [(gogoproto.enumvalue_customname) = "KindView"]; ACTIVE = 2 [(gogoproto.enumvalue_customname) = "KindActive"]; COMMITTED = 3 [(gogoproto.enumvalue_customname) = "KindCommitted"]; } message Info { string name = 1; string parent = 2; Kind kind = 3; // CreatedAt provides the time at which the snapshot was created. google.protobuf.Timestamp created_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // UpdatedAt provides the time the info was last updated. google.protobuf.Timestamp updated_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; // Labels are arbitrary data on snapshots. // // The combined size of a key/value pair cannot exceed 4096 bytes. map labels = 6; } message StatSnapshotResponse { Info info = 1 [(gogoproto.nullable) = false]; } message UpdateSnapshotRequest { string snapshotter = 1; Info info = 2 [(gogoproto.nullable) = false]; // UpdateMask specifies which fields to perform the update on. If empty, // the operation applies to all fields. // // In info, Name, Parent, Kind, Created are immutable, // other field may be updated using this mask. // If no mask is provided, all mutable field are updated. google.protobuf.FieldMask update_mask = 3; } message UpdateSnapshotResponse { Info info = 1 [(gogoproto.nullable) = false]; } message ListSnapshotsRequest{ string snapshotter = 1; // Filters contains one or more filters using the syntax defined in the // containerd filter package. // // The returned result will be those that match any of the provided // filters. Expanded, images that match the following will be // returned: // // filters[0] or filters[1] or ... or filters[n-1] or filters[n] // // If filters is zero-length or nil, all items will be returned. repeated string filters = 2; } message ListSnapshotsResponse { repeated Info info = 1 [(gogoproto.nullable) = false]; } message UsageRequest { string snapshotter = 1; string key = 2; } message UsageResponse { int64 size = 1; int64 inodes = 2; } message CleanupRequest { string snapshotter = 1; } containerd-1.5.9/api/services/tasks/000077500000000000000000000000001416535272200174045ustar00rootroot00000000000000containerd-1.5.9/api/services/tasks/v1/000077500000000000000000000000001416535272200177325ustar00rootroot00000000000000containerd-1.5.9/api/services/tasks/v1/tasks.pb.go000066400000000000000000006021471416535272200220200ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/tasks/v1/tasks.proto package tasks import ( context "context" fmt "fmt" types "github.com/containerd/containerd/api/types" task "github.com/containerd/containerd/api/types/task" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/gogo/protobuf/types" github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type CreateTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // RootFS provides the pre-chroot mounts to perform in the shim before // executing the container task. // // These are for mounts that cannot be performed in the user namespace. // Typically, these mounts should be resolved from snapshots specified on // the container object. Rootfs []*types.Mount `protobuf:"bytes,3,rep,name=rootfs,proto3" json:"rootfs,omitempty"` Stdin string `protobuf:"bytes,4,opt,name=stdin,proto3" json:"stdin,omitempty"` Stdout string `protobuf:"bytes,5,opt,name=stdout,proto3" json:"stdout,omitempty"` Stderr string `protobuf:"bytes,6,opt,name=stderr,proto3" json:"stderr,omitempty"` Terminal bool `protobuf:"varint,7,opt,name=terminal,proto3" json:"terminal,omitempty"` Checkpoint *types.Descriptor `protobuf:"bytes,8,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"` Options *types1.Any `protobuf:"bytes,9,opt,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateTaskRequest) Reset() { *m = CreateTaskRequest{} } func (*CreateTaskRequest) ProtoMessage() {} func (*CreateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{0} } func (m *CreateTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateTaskRequest.Merge(m, src) } func (m *CreateTaskRequest) XXX_Size() int { return m.Size() } func (m *CreateTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateTaskRequest proto.InternalMessageInfo type CreateTaskResponse struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateTaskResponse) Reset() { *m = CreateTaskResponse{} } func (*CreateTaskResponse) ProtoMessage() {} func (*CreateTaskResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{1} } func (m *CreateTaskResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateTaskResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CreateTaskResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateTaskResponse.Merge(m, src) } func (m *CreateTaskResponse) XXX_Size() int { return m.Size() } func (m *CreateTaskResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateTaskResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateTaskResponse proto.InternalMessageInfo type StartRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StartRequest) Reset() { *m = StartRequest{} } func (*StartRequest) ProtoMessage() {} func (*StartRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{2} } func (m *StartRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StartRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StartRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StartRequest.Merge(m, src) } func (m *StartRequest) XXX_Size() int { return m.Size() } func (m *StartRequest) XXX_DiscardUnknown() { xxx_messageInfo_StartRequest.DiscardUnknown(m) } var xxx_messageInfo_StartRequest proto.InternalMessageInfo type StartResponse struct { Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StartResponse) Reset() { *m = StartResponse{} } func (*StartResponse) ProtoMessage() {} func (*StartResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{3} } func (m *StartResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StartResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *StartResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StartResponse.Merge(m, src) } func (m *StartResponse) XXX_Size() int { return m.Size() } func (m *StartResponse) XXX_DiscardUnknown() { xxx_messageInfo_StartResponse.DiscardUnknown(m) } var xxx_messageInfo_StartResponse proto.InternalMessageInfo type DeleteTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteTaskRequest) Reset() { *m = DeleteTaskRequest{} } func (*DeleteTaskRequest) ProtoMessage() {} func (*DeleteTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{4} } func (m *DeleteTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteTaskRequest.Merge(m, src) } func (m *DeleteTaskRequest) XXX_Size() int { return m.Size() } func (m *DeleteTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteTaskRequest proto.InternalMessageInfo type DeleteResponse struct { ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"` ExitStatus uint32 `protobuf:"varint,3,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` ExitedAt time.Time `protobuf:"bytes,4,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } func (*DeleteResponse) ProtoMessage() {} func (*DeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{5} } func (m *DeleteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteResponse.Merge(m, src) } func (m *DeleteResponse) XXX_Size() int { return m.Size() } func (m *DeleteResponse) XXX_DiscardUnknown() { xxx_messageInfo_DeleteResponse.DiscardUnknown(m) } var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo type DeleteProcessRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteProcessRequest) Reset() { *m = DeleteProcessRequest{} } func (*DeleteProcessRequest) ProtoMessage() {} func (*DeleteProcessRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{6} } func (m *DeleteProcessRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteProcessRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *DeleteProcessRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteProcessRequest.Merge(m, src) } func (m *DeleteProcessRequest) XXX_Size() int { return m.Size() } func (m *DeleteProcessRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteProcessRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteProcessRequest proto.InternalMessageInfo type GetRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRequest) Reset() { *m = GetRequest{} } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{7} } func (m *GetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRequest.Merge(m, src) } func (m *GetRequest) XXX_Size() int { return m.Size() } func (m *GetRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetRequest.DiscardUnknown(m) } var xxx_messageInfo_GetRequest proto.InternalMessageInfo type GetResponse struct { Process *task.Process `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{8} } func (m *GetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *GetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetResponse.Merge(m, src) } func (m *GetResponse) XXX_Size() int { return m.Size() } func (m *GetResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetResponse.DiscardUnknown(m) } var xxx_messageInfo_GetResponse proto.InternalMessageInfo type ListTasksRequest struct { Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListTasksRequest) Reset() { *m = ListTasksRequest{} } func (*ListTasksRequest) ProtoMessage() {} func (*ListTasksRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{9} } func (m *ListTasksRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListTasksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListTasksRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListTasksRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListTasksRequest.Merge(m, src) } func (m *ListTasksRequest) XXX_Size() int { return m.Size() } func (m *ListTasksRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListTasksRequest.DiscardUnknown(m) } var xxx_messageInfo_ListTasksRequest proto.InternalMessageInfo type ListTasksResponse struct { Tasks []*task.Process `protobuf:"bytes,1,rep,name=tasks,proto3" json:"tasks,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListTasksResponse) Reset() { *m = ListTasksResponse{} } func (*ListTasksResponse) ProtoMessage() {} func (*ListTasksResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{10} } func (m *ListTasksResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListTasksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListTasksResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListTasksResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListTasksResponse.Merge(m, src) } func (m *ListTasksResponse) XXX_Size() int { return m.Size() } func (m *ListTasksResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListTasksResponse.DiscardUnknown(m) } var xxx_messageInfo_ListTasksResponse proto.InternalMessageInfo type KillRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` Signal uint32 `protobuf:"varint,3,opt,name=signal,proto3" json:"signal,omitempty"` All bool `protobuf:"varint,4,opt,name=all,proto3" json:"all,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KillRequest) Reset() { *m = KillRequest{} } func (*KillRequest) ProtoMessage() {} func (*KillRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{11} } func (m *KillRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KillRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KillRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *KillRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_KillRequest.Merge(m, src) } func (m *KillRequest) XXX_Size() int { return m.Size() } func (m *KillRequest) XXX_DiscardUnknown() { xxx_messageInfo_KillRequest.DiscardUnknown(m) } var xxx_messageInfo_KillRequest proto.InternalMessageInfo type ExecProcessRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Stdin string `protobuf:"bytes,2,opt,name=stdin,proto3" json:"stdin,omitempty"` Stdout string `protobuf:"bytes,3,opt,name=stdout,proto3" json:"stdout,omitempty"` Stderr string `protobuf:"bytes,4,opt,name=stderr,proto3" json:"stderr,omitempty"` Terminal bool `protobuf:"varint,5,opt,name=terminal,proto3" json:"terminal,omitempty"` // Spec for starting a process in the target container. // // For runc, this is a process spec, for example. Spec *types1.Any `protobuf:"bytes,6,opt,name=spec,proto3" json:"spec,omitempty"` // id of the exec process ExecID string `protobuf:"bytes,7,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecProcessRequest) Reset() { *m = ExecProcessRequest{} } func (*ExecProcessRequest) ProtoMessage() {} func (*ExecProcessRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{12} } func (m *ExecProcessRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecProcessRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ExecProcessRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecProcessRequest.Merge(m, src) } func (m *ExecProcessRequest) XXX_Size() int { return m.Size() } func (m *ExecProcessRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExecProcessRequest.DiscardUnknown(m) } var xxx_messageInfo_ExecProcessRequest proto.InternalMessageInfo type ExecProcessResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecProcessResponse) Reset() { *m = ExecProcessResponse{} } func (*ExecProcessResponse) ProtoMessage() {} func (*ExecProcessResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{13} } func (m *ExecProcessResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecProcessResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ExecProcessResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecProcessResponse.Merge(m, src) } func (m *ExecProcessResponse) XXX_Size() int { return m.Size() } func (m *ExecProcessResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExecProcessResponse.DiscardUnknown(m) } var xxx_messageInfo_ExecProcessResponse proto.InternalMessageInfo type ResizePtyRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` Width uint32 `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"` Height uint32 `protobuf:"varint,4,opt,name=height,proto3" json:"height,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResizePtyRequest) Reset() { *m = ResizePtyRequest{} } func (*ResizePtyRequest) ProtoMessage() {} func (*ResizePtyRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{14} } func (m *ResizePtyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResizePtyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResizePtyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ResizePtyRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ResizePtyRequest.Merge(m, src) } func (m *ResizePtyRequest) XXX_Size() int { return m.Size() } func (m *ResizePtyRequest) XXX_DiscardUnknown() { xxx_messageInfo_ResizePtyRequest.DiscardUnknown(m) } var xxx_messageInfo_ResizePtyRequest proto.InternalMessageInfo type CloseIORequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` Stdin bool `protobuf:"varint,3,opt,name=stdin,proto3" json:"stdin,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CloseIORequest) Reset() { *m = CloseIORequest{} } func (*CloseIORequest) ProtoMessage() {} func (*CloseIORequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{15} } func (m *CloseIORequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CloseIORequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CloseIORequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CloseIORequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CloseIORequest.Merge(m, src) } func (m *CloseIORequest) XXX_Size() int { return m.Size() } func (m *CloseIORequest) XXX_DiscardUnknown() { xxx_messageInfo_CloseIORequest.DiscardUnknown(m) } var xxx_messageInfo_CloseIORequest proto.InternalMessageInfo type PauseTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PauseTaskRequest) Reset() { *m = PauseTaskRequest{} } func (*PauseTaskRequest) ProtoMessage() {} func (*PauseTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{16} } func (m *PauseTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PauseTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PauseTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PauseTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PauseTaskRequest.Merge(m, src) } func (m *PauseTaskRequest) XXX_Size() int { return m.Size() } func (m *PauseTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_PauseTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_PauseTaskRequest proto.InternalMessageInfo type ResumeTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResumeTaskRequest) Reset() { *m = ResumeTaskRequest{} } func (*ResumeTaskRequest) ProtoMessage() {} func (*ResumeTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{17} } func (m *ResumeTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResumeTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResumeTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ResumeTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ResumeTaskRequest.Merge(m, src) } func (m *ResumeTaskRequest) XXX_Size() int { return m.Size() } func (m *ResumeTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_ResumeTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_ResumeTaskRequest proto.InternalMessageInfo type ListPidsRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPidsRequest) Reset() { *m = ListPidsRequest{} } func (*ListPidsRequest) ProtoMessage() {} func (*ListPidsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{18} } func (m *ListPidsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPidsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPidsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListPidsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPidsRequest.Merge(m, src) } func (m *ListPidsRequest) XXX_Size() int { return m.Size() } func (m *ListPidsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListPidsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListPidsRequest proto.InternalMessageInfo type ListPidsResponse struct { // Processes includes the process ID and additional process information Processes []*task.ProcessInfo `protobuf:"bytes,1,rep,name=processes,proto3" json:"processes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} } func (*ListPidsResponse) ProtoMessage() {} func (*ListPidsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{19} } func (m *ListPidsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPidsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPidsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ListPidsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPidsResponse.Merge(m, src) } func (m *ListPidsResponse) XXX_Size() int { return m.Size() } func (m *ListPidsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListPidsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListPidsResponse proto.InternalMessageInfo type CheckpointTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ParentCheckpoint github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=parent_checkpoint,json=parentCheckpoint,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"parent_checkpoint"` Options *types1.Any `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckpointTaskRequest) Reset() { *m = CheckpointTaskRequest{} } func (*CheckpointTaskRequest) ProtoMessage() {} func (*CheckpointTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{20} } func (m *CheckpointTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckpointTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckpointTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CheckpointTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckpointTaskRequest.Merge(m, src) } func (m *CheckpointTaskRequest) XXX_Size() int { return m.Size() } func (m *CheckpointTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckpointTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckpointTaskRequest proto.InternalMessageInfo type CheckpointTaskResponse struct { Descriptors []*types.Descriptor `protobuf:"bytes,1,rep,name=descriptors,proto3" json:"descriptors,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckpointTaskResponse) Reset() { *m = CheckpointTaskResponse{} } func (*CheckpointTaskResponse) ProtoMessage() {} func (*CheckpointTaskResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{21} } func (m *CheckpointTaskResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckpointTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckpointTaskResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *CheckpointTaskResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckpointTaskResponse.Merge(m, src) } func (m *CheckpointTaskResponse) XXX_Size() int { return m.Size() } func (m *CheckpointTaskResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckpointTaskResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckpointTaskResponse proto.InternalMessageInfo type UpdateTaskRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Resources *types1.Any `protobuf:"bytes,2,opt,name=resources,proto3" json:"resources,omitempty"` Annotations map[string]string `protobuf:"bytes,3,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateTaskRequest) Reset() { *m = UpdateTaskRequest{} } func (*UpdateTaskRequest) ProtoMessage() {} func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{22} } func (m *UpdateTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *UpdateTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateTaskRequest.Merge(m, src) } func (m *UpdateTaskRequest) XXX_Size() int { return m.Size() } func (m *UpdateTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateTaskRequest proto.InternalMessageInfo type MetricsRequest struct { Filters []string `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MetricsRequest) Reset() { *m = MetricsRequest{} } func (*MetricsRequest) ProtoMessage() {} func (*MetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{23} } func (m *MetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MetricsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MetricsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *MetricsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MetricsRequest.Merge(m, src) } func (m *MetricsRequest) XXX_Size() int { return m.Size() } func (m *MetricsRequest) XXX_DiscardUnknown() { xxx_messageInfo_MetricsRequest.DiscardUnknown(m) } var xxx_messageInfo_MetricsRequest proto.InternalMessageInfo type MetricsResponse struct { Metrics []*types.Metric `protobuf:"bytes,1,rep,name=metrics,proto3" json:"metrics,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MetricsResponse) Reset() { *m = MetricsResponse{} } func (*MetricsResponse) ProtoMessage() {} func (*MetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{24} } func (m *MetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MetricsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MetricsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *MetricsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MetricsResponse.Merge(m, src) } func (m *MetricsResponse) XXX_Size() int { return m.Size() } func (m *MetricsResponse) XXX_DiscardUnknown() { xxx_messageInfo_MetricsResponse.DiscardUnknown(m) } var xxx_messageInfo_MetricsResponse proto.InternalMessageInfo type WaitRequest struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ExecID string `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WaitRequest) Reset() { *m = WaitRequest{} } func (*WaitRequest) ProtoMessage() {} func (*WaitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{25} } func (m *WaitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WaitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WaitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *WaitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WaitRequest.Merge(m, src) } func (m *WaitRequest) XXX_Size() int { return m.Size() } func (m *WaitRequest) XXX_DiscardUnknown() { xxx_messageInfo_WaitRequest.DiscardUnknown(m) } var xxx_messageInfo_WaitRequest proto.InternalMessageInfo type WaitResponse struct { ExitStatus uint32 `protobuf:"varint,1,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` ExitedAt time.Time `protobuf:"bytes,2,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WaitResponse) Reset() { *m = WaitResponse{} } func (*WaitResponse) ProtoMessage() {} func (*WaitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_310e7127b8a26f14, []int{26} } func (m *WaitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WaitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WaitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *WaitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WaitResponse.Merge(m, src) } func (m *WaitResponse) XXX_Size() int { return m.Size() } func (m *WaitResponse) XXX_DiscardUnknown() { xxx_messageInfo_WaitResponse.DiscardUnknown(m) } var xxx_messageInfo_WaitResponse proto.InternalMessageInfo func init() { proto.RegisterType((*CreateTaskRequest)(nil), "containerd.services.tasks.v1.CreateTaskRequest") proto.RegisterType((*CreateTaskResponse)(nil), "containerd.services.tasks.v1.CreateTaskResponse") proto.RegisterType((*StartRequest)(nil), "containerd.services.tasks.v1.StartRequest") proto.RegisterType((*StartResponse)(nil), "containerd.services.tasks.v1.StartResponse") proto.RegisterType((*DeleteTaskRequest)(nil), "containerd.services.tasks.v1.DeleteTaskRequest") proto.RegisterType((*DeleteResponse)(nil), "containerd.services.tasks.v1.DeleteResponse") proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.services.tasks.v1.DeleteProcessRequest") proto.RegisterType((*GetRequest)(nil), "containerd.services.tasks.v1.GetRequest") proto.RegisterType((*GetResponse)(nil), "containerd.services.tasks.v1.GetResponse") proto.RegisterType((*ListTasksRequest)(nil), "containerd.services.tasks.v1.ListTasksRequest") proto.RegisterType((*ListTasksResponse)(nil), "containerd.services.tasks.v1.ListTasksResponse") proto.RegisterType((*KillRequest)(nil), "containerd.services.tasks.v1.KillRequest") proto.RegisterType((*ExecProcessRequest)(nil), "containerd.services.tasks.v1.ExecProcessRequest") proto.RegisterType((*ExecProcessResponse)(nil), "containerd.services.tasks.v1.ExecProcessResponse") proto.RegisterType((*ResizePtyRequest)(nil), "containerd.services.tasks.v1.ResizePtyRequest") proto.RegisterType((*CloseIORequest)(nil), "containerd.services.tasks.v1.CloseIORequest") proto.RegisterType((*PauseTaskRequest)(nil), "containerd.services.tasks.v1.PauseTaskRequest") proto.RegisterType((*ResumeTaskRequest)(nil), "containerd.services.tasks.v1.ResumeTaskRequest") proto.RegisterType((*ListPidsRequest)(nil), "containerd.services.tasks.v1.ListPidsRequest") proto.RegisterType((*ListPidsResponse)(nil), "containerd.services.tasks.v1.ListPidsResponse") proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.services.tasks.v1.CheckpointTaskRequest") proto.RegisterType((*CheckpointTaskResponse)(nil), "containerd.services.tasks.v1.CheckpointTaskResponse") proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.services.tasks.v1.UpdateTaskRequest") proto.RegisterMapType((map[string]string)(nil), "containerd.services.tasks.v1.UpdateTaskRequest.AnnotationsEntry") proto.RegisterType((*MetricsRequest)(nil), "containerd.services.tasks.v1.MetricsRequest") proto.RegisterType((*MetricsResponse)(nil), "containerd.services.tasks.v1.MetricsResponse") proto.RegisterType((*WaitRequest)(nil), "containerd.services.tasks.v1.WaitRequest") proto.RegisterType((*WaitResponse)(nil), "containerd.services.tasks.v1.WaitResponse") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/tasks/v1/tasks.proto", fileDescriptor_310e7127b8a26f14) } var fileDescriptor_310e7127b8a26f14 = []byte{ // 1376 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5b, 0x6f, 0x1b, 0x45, 0x14, 0xee, 0xfa, 0xee, 0xe3, 0xa4, 0x4d, 0x96, 0x34, 0x98, 0xa5, 0x8a, 0xc3, 0xf2, 0x62, 0x02, 0x5d, 0x53, 0x17, 0x55, 0x55, 0x5b, 0x55, 0xe4, 0x46, 0x64, 0x41, 0xd5, 0x74, 0x5b, 0xa0, 0xaa, 0x84, 0xc2, 0xc6, 0x3b, 0x71, 0x46, 0xb1, 0x77, 0xb6, 0x3b, 0xe3, 0xb4, 0xe6, 0x05, 0x7e, 0x42, 0x5f, 0x79, 0x81, 0xbf, 0x93, 0x47, 0x1e, 0x11, 0xaa, 0x02, 0xf5, 0xbf, 0xe0, 0x0d, 0xcd, 0x65, 0xd7, 0x1b, 0x3b, 0xf6, 0x3a, 0x4d, 0xc3, 0x4b, 0x32, 0x33, 0x7b, 0xce, 0x99, 0x33, 0xdf, 0xb9, 0x7d, 0x09, 0xac, 0xb5, 0x30, 0xdb, 0xef, 0xee, 0x5a, 0x4d, 0xd2, 0xa9, 0x35, 0x89, 0xc7, 0x1c, 0xec, 0xa1, 0xc0, 0x8d, 0x2f, 0x1d, 0x1f, 0xd7, 0x28, 0x0a, 0x0e, 0x71, 0x13, 0xd1, 0x1a, 0x73, 0xe8, 0x01, 0xad, 0x1d, 0xde, 0x90, 0x0b, 0xcb, 0x0f, 0x08, 0x23, 0xfa, 0xb5, 0x81, 0xb4, 0x15, 0x4a, 0x5a, 0x52, 0xe0, 0xf0, 0x86, 0xf1, 0x61, 0x8b, 0x90, 0x56, 0x1b, 0xd5, 0x84, 0xec, 0x6e, 0x77, 0xaf, 0x86, 0x3a, 0x3e, 0xeb, 0x49, 0x55, 0xe3, 0x83, 0xe1, 0x8f, 0x8e, 0x17, 0x7e, 0x5a, 0x68, 0x91, 0x16, 0x11, 0xcb, 0x1a, 0x5f, 0xa9, 0xd3, 0x5b, 0x53, 0xf9, 0xcb, 0x7a, 0x3e, 0xa2, 0xb5, 0x0e, 0xe9, 0x7a, 0x4c, 0xe9, 0xdd, 0x3e, 0x8b, 0x1e, 0x62, 0x01, 0x6e, 0xaa, 0xd7, 0x19, 0x77, 0xcf, 0xa0, 0xe9, 0x22, 0xda, 0x0c, 0xb0, 0xcf, 0x48, 0xa0, 0x94, 0xef, 0x9c, 0x41, 0x99, 0x23, 0x26, 0x7e, 0x28, 0xdd, 0xca, 0x30, 0x36, 0x0c, 0x77, 0x10, 0x65, 0x4e, 0xc7, 0x97, 0x02, 0xe6, 0x51, 0x0a, 0xe6, 0xd7, 0x03, 0xe4, 0x30, 0xf4, 0xc4, 0xa1, 0x07, 0x36, 0x7a, 0xde, 0x45, 0x94, 0xe9, 0x75, 0x98, 0x89, 0xcc, 0xef, 0x60, 0xb7, 0xac, 0x2d, 0x6b, 0xd5, 0xe2, 0xda, 0x95, 0xfe, 0x71, 0xa5, 0xb4, 0x1e, 0x9e, 0x37, 0x36, 0xec, 0x52, 0x24, 0xd4, 0x70, 0xf5, 0x1a, 0xe4, 0x02, 0x42, 0xd8, 0x1e, 0x2d, 0xa7, 0x97, 0xd3, 0xd5, 0x52, 0xfd, 0x7d, 0x2b, 0x16, 0x52, 0xe1, 0x9d, 0xf5, 0x80, 0x83, 0x69, 0x2b, 0x31, 0x7d, 0x01, 0xb2, 0x94, 0xb9, 0xd8, 0x2b, 0x67, 0xb8, 0x75, 0x5b, 0x6e, 0xf4, 0x45, 0xc8, 0x51, 0xe6, 0x92, 0x2e, 0x2b, 0x67, 0xc5, 0xb1, 0xda, 0xa9, 0x73, 0x14, 0x04, 0xe5, 0x5c, 0x74, 0x8e, 0x82, 0x40, 0x37, 0xa0, 0xc0, 0x50, 0xd0, 0xc1, 0x9e, 0xd3, 0x2e, 0xe7, 0x97, 0xb5, 0x6a, 0xc1, 0x8e, 0xf6, 0xfa, 0x3d, 0x80, 0xe6, 0x3e, 0x6a, 0x1e, 0xf8, 0x04, 0x7b, 0xac, 0x5c, 0x58, 0xd6, 0xaa, 0xa5, 0xfa, 0xb5, 0x51, 0xb7, 0x36, 0x22, 0xc4, 0xed, 0x98, 0xbc, 0x6e, 0x41, 0x9e, 0xf8, 0x0c, 0x13, 0x8f, 0x96, 0x8b, 0x42, 0x75, 0xc1, 0x92, 0x68, 0x5a, 0x21, 0x9a, 0xd6, 0xaa, 0xd7, 0xb3, 0x43, 0x21, 0xf3, 0x19, 0xe8, 0x71, 0x24, 0xa9, 0x4f, 0x3c, 0x8a, 0xde, 0x0a, 0xca, 0x39, 0x48, 0xfb, 0xd8, 0x2d, 0xa7, 0x96, 0xb5, 0xea, 0xac, 0xcd, 0x97, 0x66, 0x0b, 0x66, 0x1e, 0x33, 0x27, 0x60, 0xe7, 0x09, 0xd0, 0xc7, 0x90, 0x47, 0x2f, 0x51, 0x73, 0x47, 0x59, 0x2e, 0xae, 0x41, 0xff, 0xb8, 0x92, 0xdb, 0x7c, 0x89, 0x9a, 0x8d, 0x0d, 0x3b, 0xc7, 0x3f, 0x35, 0x5c, 0xf3, 0x23, 0x98, 0x55, 0x17, 0x29, 0xff, 0x95, 0x2f, 0xda, 0xc0, 0x97, 0x2d, 0x98, 0xdf, 0x40, 0x6d, 0x74, 0xee, 0x8c, 0x31, 0x7f, 0xd3, 0xe0, 0xb2, 0xb4, 0x14, 0xdd, 0xb6, 0x08, 0xa9, 0x48, 0x39, 0xd7, 0x3f, 0xae, 0xa4, 0x1a, 0x1b, 0x76, 0x0a, 0x9f, 0x82, 0x88, 0x5e, 0x81, 0x12, 0x7a, 0x89, 0xd9, 0x0e, 0x65, 0x0e, 0xeb, 0xf2, 0x9c, 0xe3, 0x5f, 0x80, 0x1f, 0x3d, 0x16, 0x27, 0xfa, 0x2a, 0x14, 0xf9, 0x0e, 0xb9, 0x3b, 0x0e, 0x13, 0x29, 0x56, 0xaa, 0x1b, 0x23, 0x01, 0x7c, 0x12, 0x96, 0xc3, 0x5a, 0xe1, 0xe8, 0xb8, 0x72, 0xe9, 0xd5, 0xdf, 0x15, 0xcd, 0x2e, 0x48, 0xb5, 0x55, 0x66, 0x12, 0x58, 0x90, 0xfe, 0x6d, 0x07, 0xa4, 0x89, 0x28, 0xbd, 0x70, 0xf4, 0x11, 0xc0, 0x16, 0xba, 0xf8, 0x20, 0x6f, 0x42, 0x49, 0x5c, 0xa3, 0x40, 0xbf, 0x05, 0x79, 0x5f, 0x3e, 0x50, 0x5c, 0x31, 0x54, 0x23, 0x87, 0x37, 0x54, 0x99, 0x84, 0x20, 0x84, 0xc2, 0xe6, 0x0a, 0xcc, 0x7d, 0x83, 0x29, 0xe3, 0x69, 0x10, 0x41, 0xb3, 0x08, 0xb9, 0x3d, 0xdc, 0x66, 0x28, 0x90, 0xde, 0xda, 0x6a, 0xc7, 0x93, 0x26, 0x26, 0x1b, 0xd5, 0x46, 0x56, 0xb4, 0xf8, 0xb2, 0x26, 0x3a, 0xc6, 0xe4, 0x6b, 0xa5, 0xa8, 0xf9, 0x4a, 0x83, 0xd2, 0xd7, 0xb8, 0xdd, 0xbe, 0x68, 0x90, 0x44, 0xc3, 0xc1, 0x2d, 0xde, 0x56, 0x64, 0x6e, 0xa9, 0x1d, 0x4f, 0x45, 0xa7, 0xdd, 0x16, 0x19, 0x55, 0xb0, 0xf9, 0xd2, 0xfc, 0x57, 0x03, 0x9d, 0x2b, 0xbf, 0x83, 0x2c, 0x89, 0x7a, 0x62, 0xea, 0xf4, 0x9e, 0x98, 0x1e, 0xd3, 0x13, 0x33, 0x63, 0x7b, 0x62, 0x76, 0xa8, 0x27, 0x56, 0x21, 0x43, 0x7d, 0xd4, 0x14, 0x5d, 0x74, 0x5c, 0x4b, 0x13, 0x12, 0x71, 0x94, 0xf2, 0x63, 0x53, 0xe9, 0x2a, 0xbc, 0x77, 0xe2, 0xe9, 0x32, 0xb2, 0xe6, 0xaf, 0x1a, 0xcc, 0xd9, 0x88, 0xe2, 0x9f, 0xd0, 0x36, 0xeb, 0x5d, 0x78, 0xa8, 0x16, 0x20, 0xfb, 0x02, 0xbb, 0x6c, 0x5f, 0x45, 0x4a, 0x6e, 0x38, 0x3a, 0xfb, 0x08, 0xb7, 0xf6, 0x65, 0xf5, 0xcf, 0xda, 0x6a, 0x67, 0xfe, 0x0c, 0x97, 0xd7, 0xdb, 0x84, 0xa2, 0xc6, 0xc3, 0xff, 0xc3, 0x31, 0x19, 0xce, 0xb4, 0x88, 0x82, 0xdc, 0x98, 0x5f, 0xc1, 0xdc, 0xb6, 0xd3, 0xa5, 0xe7, 0xee, 0x9f, 0x5b, 0x30, 0x6f, 0x23, 0xda, 0xed, 0x9c, 0xdb, 0xd0, 0x26, 0x5c, 0xe1, 0xc5, 0xb9, 0x8d, 0xdd, 0xf3, 0x24, 0xaf, 0x69, 0xcb, 0x7e, 0x20, 0xcd, 0xa8, 0x12, 0xbf, 0x0f, 0x45, 0xd5, 0x2e, 0x50, 0x58, 0xe6, 0xcb, 0x93, 0xca, 0xbc, 0xe1, 0xed, 0x11, 0x7b, 0xa0, 0x62, 0xbe, 0xd6, 0xe0, 0xea, 0x7a, 0x34, 0x93, 0xcf, 0xcb, 0x51, 0x76, 0x60, 0xde, 0x77, 0x02, 0xe4, 0xb1, 0x9d, 0x18, 0x2f, 0x90, 0xe1, 0xab, 0xf3, 0xfe, 0xff, 0xd7, 0x71, 0x65, 0x25, 0xc6, 0xb6, 0x88, 0x8f, 0xbc, 0x48, 0x9d, 0xd6, 0x5a, 0xe4, 0xba, 0x8b, 0x5b, 0x88, 0x32, 0x6b, 0x43, 0xfc, 0xb2, 0xe7, 0xa4, 0xb1, 0xf5, 0x53, 0x39, 0x43, 0x7a, 0x1a, 0xce, 0xf0, 0x14, 0x16, 0x87, 0x5f, 0x17, 0x01, 0x57, 0x1a, 0x30, 0xc1, 0x53, 0x3b, 0xe4, 0x08, 0x79, 0x89, 0x2b, 0x98, 0xbf, 0xa7, 0x60, 0xfe, 0x5b, 0xdf, 0x7d, 0x07, 0xc4, 0xae, 0x0e, 0xc5, 0x00, 0x51, 0xd2, 0x0d, 0x9a, 0x88, 0x0a, 0xb0, 0xc6, 0xbd, 0x6a, 0x20, 0xa6, 0xef, 0x42, 0xc9, 0xf1, 0x3c, 0xc2, 0x9c, 0x10, 0x0b, 0xee, 0xfd, 0x97, 0xd6, 0x24, 0x92, 0x6f, 0x8d, 0x78, 0x6b, 0xad, 0x0e, 0x4c, 0x6c, 0x7a, 0x2c, 0xe8, 0xd9, 0x71, 0xa3, 0xc6, 0x7d, 0x98, 0x1b, 0x16, 0xe0, 0xcd, 0xf9, 0x00, 0xf5, 0xd4, 0xec, 0xe1, 0x4b, 0x5e, 0x82, 0x87, 0x4e, 0xbb, 0x8b, 0xc2, 0x8e, 0x2a, 0x36, 0x77, 0x52, 0xb7, 0x35, 0x73, 0x05, 0x2e, 0x3f, 0x90, 0x2c, 0x3d, 0x44, 0xa7, 0x0c, 0x79, 0x39, 0xae, 0x24, 0xde, 0x45, 0x3b, 0xdc, 0xf2, 0x0a, 0x89, 0x64, 0xa3, 0xe1, 0x95, 0x57, 0x24, 0x5f, 0x05, 0xa7, 0x7c, 0x0a, 0xe1, 0x15, 0x02, 0x76, 0x28, 0x68, 0xee, 0x41, 0xe9, 0x7b, 0x07, 0x5f, 0xfc, 0x80, 0x0f, 0x60, 0x46, 0xde, 0xa3, 0x7c, 0x1d, 0x22, 0x4b, 0xda, 0x64, 0xb2, 0x94, 0x7a, 0x1b, 0xb2, 0x54, 0x7f, 0x3d, 0x03, 0x59, 0x31, 0xde, 0xf5, 0x03, 0xc8, 0x49, 0x22, 0xac, 0xd7, 0x26, 0x47, 0x7c, 0xe4, 0x0f, 0x0f, 0xe3, 0xf3, 0xe9, 0x15, 0xd4, 0xd3, 0x7e, 0x84, 0xac, 0x20, 0xac, 0xfa, 0xca, 0x64, 0xd5, 0x38, 0x7d, 0x36, 0x3e, 0x9d, 0x4a, 0x56, 0xdd, 0xd0, 0x82, 0x9c, 0x64, 0x81, 0x49, 0xcf, 0x19, 0x61, 0xc5, 0xc6, 0x67, 0xd3, 0x28, 0x44, 0x17, 0x3d, 0x87, 0xd9, 0x13, 0x74, 0x53, 0xaf, 0x4f, 0xa3, 0x7e, 0x92, 0x75, 0x9c, 0xf1, 0xca, 0x67, 0x90, 0xde, 0x42, 0x4c, 0xaf, 0x4e, 0x56, 0x1a, 0x70, 0x52, 0xe3, 0x93, 0x29, 0x24, 0x23, 0xdc, 0x32, 0x7c, 0x1c, 0xe8, 0xd6, 0x64, 0x95, 0x61, 0x0a, 0x69, 0xd4, 0xa6, 0x96, 0x57, 0x17, 0x35, 0x20, 0xc3, 0x19, 0xa1, 0x9e, 0xe0, 0x5b, 0x8c, 0x35, 0x1a, 0x8b, 0x23, 0xc9, 0xbd, 0xd9, 0xf1, 0x59, 0x4f, 0xdf, 0x86, 0x0c, 0x2f, 0x25, 0x3d, 0x21, 0x0f, 0x47, 0xd9, 0xde, 0x58, 0x8b, 0x8f, 0xa1, 0x18, 0x11, 0xa1, 0x24, 0x28, 0x86, 0x19, 0xd3, 0x58, 0xa3, 0x0f, 0x21, 0xaf, 0x28, 0x8c, 0x9e, 0x10, 0xef, 0x93, 0x4c, 0x67, 0x82, 0xc1, 0xac, 0xa0, 0x24, 0x49, 0x1e, 0x0e, 0xf3, 0x96, 0xb1, 0x06, 0x1f, 0x41, 0x4e, 0x72, 0x93, 0xa4, 0xa2, 0x19, 0x61, 0x30, 0x63, 0x4d, 0x62, 0x28, 0x84, 0xf4, 0x42, 0xbf, 0x9e, 0x9c, 0x23, 0x31, 0x36, 0x63, 0x58, 0xd3, 0x8a, 0xab, 0x8c, 0x7a, 0x01, 0x10, 0x1b, 0xea, 0x37, 0x13, 0x20, 0x3e, 0x8d, 0x9e, 0x18, 0x5f, 0x9c, 0x4d, 0x49, 0x5d, 0xfc, 0x08, 0x72, 0x72, 0x0c, 0x26, 0xc1, 0x36, 0x32, 0x2c, 0xc7, 0xc2, 0xb6, 0x07, 0x79, 0x35, 0xba, 0x92, 0x72, 0xe5, 0xe4, 0x34, 0x34, 0xae, 0x4f, 0x29, 0xad, 0x5c, 0xff, 0x01, 0x32, 0x7c, 0xe6, 0x24, 0x55, 0x61, 0x6c, 0xfe, 0x19, 0x2b, 0xd3, 0x88, 0x4a, 0xf3, 0x6b, 0xdf, 0x1d, 0xbd, 0x59, 0xba, 0xf4, 0xe7, 0x9b, 0xa5, 0x4b, 0xbf, 0xf4, 0x97, 0xb4, 0xa3, 0xfe, 0x92, 0xf6, 0x47, 0x7f, 0x49, 0xfb, 0xa7, 0xbf, 0xa4, 0x3d, 0xbb, 0xf7, 0x76, 0xff, 0x7e, 0xbc, 0x2b, 0x16, 0x4f, 0x53, 0xbb, 0x39, 0x01, 0xd8, 0xcd, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x55, 0xbf, 0x54, 0xc7, 0x14, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // TasksClient is the client API for Tasks service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type TasksClient interface { // Create a task. Create(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error) // Start a process. Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) // Delete a task and on disk state. Delete(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteResponse, error) DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) List(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) // Kill a task or process. Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*types1.Empty, error) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*types1.Empty, error) ResizePty(ctx context.Context, in *ResizePtyRequest, opts ...grpc.CallOption) (*types1.Empty, error) CloseIO(ctx context.Context, in *CloseIORequest, opts ...grpc.CallOption) (*types1.Empty, error) Pause(ctx context.Context, in *PauseTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) Resume(ctx context.Context, in *ResumeTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) ListPids(ctx context.Context, in *ListPidsRequest, opts ...grpc.CallOption) (*ListPidsResponse, error) Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*CheckpointTaskResponse, error) Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) Metrics(ctx context.Context, in *MetricsRequest, opts ...grpc.CallOption) (*MetricsResponse, error) Wait(ctx context.Context, in *WaitRequest, opts ...grpc.CallOption) (*WaitResponse, error) } type tasksClient struct { cc *grpc.ClientConn } func NewTasksClient(cc *grpc.ClientConn) TasksClient { return &tasksClient{cc} } func (c *tasksClient) Create(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskResponse, error) { out := new(CreateTaskResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) { out := new(StartResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Start", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Delete(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { out := new(DeleteResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) DeleteProcess(ctx context.Context, in *DeleteProcessRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { out := new(DeleteResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/DeleteProcess", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { out := new(GetResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) List(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) { out := new(ListTasksResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/List", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Kill(ctx context.Context, in *KillRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Kill", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Exec(ctx context.Context, in *ExecProcessRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Exec", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) ResizePty(ctx context.Context, in *ResizePtyRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/ResizePty", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) CloseIO(ctx context.Context, in *CloseIORequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/CloseIO", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Pause(ctx context.Context, in *PauseTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Pause", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Resume(ctx context.Context, in *ResumeTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Resume", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) ListPids(ctx context.Context, in *ListPidsRequest, opts ...grpc.CallOption) (*ListPidsResponse, error) { out := new(ListPidsResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/ListPids", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Checkpoint(ctx context.Context, in *CheckpointTaskRequest, opts ...grpc.CallOption) (*CheckpointTaskResponse, error) { out := new(CheckpointTaskResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Checkpoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Update(ctx context.Context, in *UpdateTaskRequest, opts ...grpc.CallOption) (*types1.Empty, error) { out := new(types1.Empty) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Metrics(ctx context.Context, in *MetricsRequest, opts ...grpc.CallOption) (*MetricsResponse, error) { out := new(MetricsResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Metrics", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tasksClient) Wait(ctx context.Context, in *WaitRequest, opts ...grpc.CallOption) (*WaitResponse, error) { out := new(WaitResponse) err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Wait", in, out, opts...) if err != nil { return nil, err } return out, nil } // TasksServer is the server API for Tasks service. type TasksServer interface { // Create a task. Create(context.Context, *CreateTaskRequest) (*CreateTaskResponse, error) // Start a process. Start(context.Context, *StartRequest) (*StartResponse, error) // Delete a task and on disk state. Delete(context.Context, *DeleteTaskRequest) (*DeleteResponse, error) DeleteProcess(context.Context, *DeleteProcessRequest) (*DeleteResponse, error) Get(context.Context, *GetRequest) (*GetResponse, error) List(context.Context, *ListTasksRequest) (*ListTasksResponse, error) // Kill a task or process. Kill(context.Context, *KillRequest) (*types1.Empty, error) Exec(context.Context, *ExecProcessRequest) (*types1.Empty, error) ResizePty(context.Context, *ResizePtyRequest) (*types1.Empty, error) CloseIO(context.Context, *CloseIORequest) (*types1.Empty, error) Pause(context.Context, *PauseTaskRequest) (*types1.Empty, error) Resume(context.Context, *ResumeTaskRequest) (*types1.Empty, error) ListPids(context.Context, *ListPidsRequest) (*ListPidsResponse, error) Checkpoint(context.Context, *CheckpointTaskRequest) (*CheckpointTaskResponse, error) Update(context.Context, *UpdateTaskRequest) (*types1.Empty, error) Metrics(context.Context, *MetricsRequest) (*MetricsResponse, error) Wait(context.Context, *WaitRequest) (*WaitResponse, error) } // UnimplementedTasksServer can be embedded to have forward compatible implementations. type UnimplementedTasksServer struct { } func (*UnimplementedTasksServer) Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Create not implemented") } func (*UnimplementedTasksServer) Start(ctx context.Context, req *StartRequest) (*StartResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Start not implemented") } func (*UnimplementedTasksServer) Delete(ctx context.Context, req *DeleteTaskRequest) (*DeleteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") } func (*UnimplementedTasksServer) DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DeleteProcess not implemented") } func (*UnimplementedTasksServer) Get(ctx context.Context, req *GetRequest) (*GetResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") } func (*UnimplementedTasksServer) List(ctx context.Context, req *ListTasksRequest) (*ListTasksResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method List not implemented") } func (*UnimplementedTasksServer) Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Kill not implemented") } func (*UnimplementedTasksServer) Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Exec not implemented") } func (*UnimplementedTasksServer) ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method ResizePty not implemented") } func (*UnimplementedTasksServer) CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method CloseIO not implemented") } func (*UnimplementedTasksServer) Pause(ctx context.Context, req *PauseTaskRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Pause not implemented") } func (*UnimplementedTasksServer) Resume(ctx context.Context, req *ResumeTaskRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Resume not implemented") } func (*UnimplementedTasksServer) ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListPids not implemented") } func (*UnimplementedTasksServer) Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*CheckpointTaskResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Checkpoint not implemented") } func (*UnimplementedTasksServer) Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error) { return nil, status.Errorf(codes.Unimplemented, "method Update not implemented") } func (*UnimplementedTasksServer) Metrics(ctx context.Context, req *MetricsRequest) (*MetricsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Metrics not implemented") } func (*UnimplementedTasksServer) Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Wait not implemented") } func RegisterTasksServer(s *grpc.Server, srv TasksServer) { s.RegisterService(&_Tasks_serviceDesc, srv) } func _Tasks_Create_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.(TasksServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Create(ctx, req.(*CreateTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StartRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Start(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Start", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Start(ctx, req.(*StartRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Delete_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.(TasksServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Delete(ctx, req.(*DeleteTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_DeleteProcess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteProcessRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).DeleteProcess(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/DeleteProcess", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).DeleteProcess(ctx, req.(*DeleteProcessRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_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.(TasksServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Get(ctx, req.(*GetRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_List_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.(TasksServer).List(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/List", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).List(ctx, req.(*ListTasksRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Kill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(KillRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Kill(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Kill", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Kill(ctx, req.(*KillRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Exec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExecProcessRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Exec(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Exec", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Exec(ctx, req.(*ExecProcessRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_ResizePty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResizePtyRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).ResizePty(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/ResizePty", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).ResizePty(ctx, req.(*ResizePtyRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_CloseIO_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CloseIORequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).CloseIO(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/CloseIO", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).CloseIO(ctx, req.(*CloseIORequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Pause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PauseTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Pause(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Pause", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Pause(ctx, req.(*PauseTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Resume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResumeTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Resume(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Resume", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Resume(ctx, req.(*ResumeTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_ListPids_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListPidsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).ListPids(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/ListPids", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).ListPids(ctx, req.(*ListPidsRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Checkpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CheckpointTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Checkpoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Checkpoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Checkpoint(ctx, req.(*CheckpointTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Update(ctx, req.(*UpdateTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Metrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MetricsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Metrics(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Metrics", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Metrics(ctx, req.(*MetricsRequest)) } return interceptor(ctx, in, info, handler) } func _Tasks_Wait_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(WaitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TasksServer).Wait(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.tasks.v1.Tasks/Wait", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TasksServer).Wait(ctx, req.(*WaitRequest)) } return interceptor(ctx, in, info, handler) } var _Tasks_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.tasks.v1.Tasks", HandlerType: (*TasksServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Create", Handler: _Tasks_Create_Handler, }, { MethodName: "Start", Handler: _Tasks_Start_Handler, }, { MethodName: "Delete", Handler: _Tasks_Delete_Handler, }, { MethodName: "DeleteProcess", Handler: _Tasks_DeleteProcess_Handler, }, { MethodName: "Get", Handler: _Tasks_Get_Handler, }, { MethodName: "List", Handler: _Tasks_List_Handler, }, { MethodName: "Kill", Handler: _Tasks_Kill_Handler, }, { MethodName: "Exec", Handler: _Tasks_Exec_Handler, }, { MethodName: "ResizePty", Handler: _Tasks_ResizePty_Handler, }, { MethodName: "CloseIO", Handler: _Tasks_CloseIO_Handler, }, { MethodName: "Pause", Handler: _Tasks_Pause_Handler, }, { MethodName: "Resume", Handler: _Tasks_Resume_Handler, }, { MethodName: "ListPids", Handler: _Tasks_ListPids_Handler, }, { MethodName: "Checkpoint", Handler: _Tasks_Checkpoint_Handler, }, { MethodName: "Update", Handler: _Tasks_Update_Handler, }, { MethodName: "Metrics", Handler: _Tasks_Metrics_Handler, }, { MethodName: "Wait", Handler: _Tasks_Wait_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/tasks/v1/tasks.proto", } func (m *CreateTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Options != nil { { size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x4a } if m.Checkpoint != nil { { size, err := m.Checkpoint.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x42 } if m.Terminal { i-- if m.Terminal { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x38 } if len(m.Stderr) > 0 { i -= len(m.Stderr) copy(dAtA[i:], m.Stderr) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stderr))) i-- dAtA[i] = 0x32 } if len(m.Stdout) > 0 { i -= len(m.Stdout) copy(dAtA[i:], m.Stdout) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stdout))) i-- dAtA[i] = 0x2a } if len(m.Stdin) > 0 { i -= len(m.Stdin) copy(dAtA[i:], m.Stdin) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stdin))) i-- dAtA[i] = 0x22 } if len(m.Rootfs) > 0 { for iNdEx := len(m.Rootfs) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Rootfs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CreateTaskResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateTaskResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateTaskResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Pid != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x10 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StartRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StartRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StartRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StartResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StartResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StartResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Pid != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *DeleteTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):]) if err3 != nil { return 0, err3 } i -= n3 i = encodeVarintTasks(dAtA, i, uint64(n3)) i-- dAtA[i] = 0x22 if m.ExitStatus != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.ExitStatus)) i-- dAtA[i] = 0x18 } if m.Pid != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x10 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DeleteProcessRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteProcessRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DeleteProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *GetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Process != nil { { size, err := m.Process.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListTasksRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListTasksRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListTasksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filter) > 0 { i -= len(m.Filter) copy(dAtA[i:], m.Filter) i = encodeVarintTasks(dAtA, i, uint64(len(m.Filter))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListTasksResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListTasksResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListTasksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Tasks) > 0 { for iNdEx := len(m.Tasks) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Tasks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *KillRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KillRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *KillRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.All { i-- if m.All { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if m.Signal != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Signal)) i-- dAtA[i] = 0x18 } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecProcessRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecProcessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x3a } if m.Spec != nil { { size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x32 } if m.Terminal { i-- if m.Terminal { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x28 } if len(m.Stderr) > 0 { i -= len(m.Stderr) copy(dAtA[i:], m.Stderr) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stderr))) i-- dAtA[i] = 0x22 } if len(m.Stdout) > 0 { i -= len(m.Stdout) copy(dAtA[i:], m.Stdout) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stdout))) i-- dAtA[i] = 0x1a } if len(m.Stdin) > 0 { i -= len(m.Stdin) copy(dAtA[i:], m.Stdin) i = encodeVarintTasks(dAtA, i, uint64(len(m.Stdin))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecProcessResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecProcessResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } return len(dAtA) - i, nil } func (m *ResizePtyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResizePtyRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ResizePtyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Height != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Height)) i-- dAtA[i] = 0x20 } if m.Width != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.Width)) i-- dAtA[i] = 0x18 } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CloseIORequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CloseIORequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CloseIORequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Stdin { i-- if m.Stdin { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PauseTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PauseTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PauseTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ResumeTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResumeTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ResumeTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListPidsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListPidsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPidsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListPidsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPidsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Processes) > 0 { for iNdEx := len(m.Processes) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Processes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *CheckpointTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CheckpointTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Options != nil { { size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if len(m.ParentCheckpoint) > 0 { i -= len(m.ParentCheckpoint) copy(dAtA[i:], m.ParentCheckpoint) i = encodeVarintTasks(dAtA, i, uint64(len(m.ParentCheckpoint))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CheckpointTaskResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckpointTaskResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CheckpointTaskResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Descriptors) > 0 { for iNdEx := len(m.Descriptors) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Descriptors[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UpdateTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateTaskRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintTasks(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintTasks(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintTasks(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if m.Resources != nil { { size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *MetricsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MetricsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MetricsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Filters) > 0 { for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Filters[iNdEx]) copy(dAtA[i:], m.Filters[iNdEx]) i = encodeVarintTasks(dAtA, i, uint64(len(m.Filters[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *MetricsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MetricsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MetricsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Metrics) > 0 { for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTasks(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *WaitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WaitRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WaitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ExecID) > 0 { i -= len(m.ExecID) copy(dAtA[i:], m.ExecID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ExecID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTasks(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *WaitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WaitResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WaitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):]) if err8 != nil { return 0, err8 } i -= n8 i = encodeVarintTasks(dAtA, i, uint64(n8)) i-- dAtA[i] = 0x12 if m.ExitStatus != 0 { i = encodeVarintTasks(dAtA, i, uint64(m.ExitStatus)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func encodeVarintTasks(dAtA []byte, offset int, v uint64) int { offset -= sovTasks(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *CreateTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if len(m.Rootfs) > 0 { for _, e := range m.Rootfs { l = e.Size() n += 1 + l + sovTasks(uint64(l)) } } l = len(m.Stdin) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.Stdout) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.Stderr) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Terminal { n += 2 } if m.Checkpoint != nil { l = m.Checkpoint.Size() n += 1 + l + sovTasks(uint64(l)) } if m.Options != nil { l = m.Options.Size() n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateTaskResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Pid != 0 { n += 1 + sovTasks(uint64(m.Pid)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StartRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StartResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Pid != 0 { n += 1 + sovTasks(uint64(m.Pid)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Pid != 0 { n += 1 + sovTasks(uint64(m.Pid)) } if m.ExitStatus != 0 { n += 1 + sovTasks(uint64(m.ExitStatus)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) n += 1 + l + sovTasks(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteProcessRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Process != nil { l = m.Process.Size() n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListTasksRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Filter) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListTasksResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Tasks) > 0 { for _, e := range m.Tasks { l = e.Size() n += 1 + l + sovTasks(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KillRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Signal != 0 { n += 1 + sovTasks(uint64(m.Signal)) } if m.All { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExecProcessRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.Stdin) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.Stdout) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.Stderr) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Terminal { n += 2 } if m.Spec != nil { l = m.Spec.Size() n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExecProcessResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResizePtyRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Width != 0 { n += 1 + sovTasks(uint64(m.Width)) } if m.Height != 0 { n += 1 + sovTasks(uint64(m.Height)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CloseIORequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Stdin { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PauseTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResumeTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListPidsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListPidsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Processes) > 0 { for _, e := range m.Processes { l = e.Size() n += 1 + l + sovTasks(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckpointTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ParentCheckpoint) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Options != nil { l = m.Options.Size() n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckpointTaskResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Descriptors) > 0 { for _, e := range m.Descriptors { l = e.Size() n += 1 + l + sovTasks(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateTaskRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.Resources != nil { l = m.Resources.Size() n += 1 + l + sovTasks(uint64(l)) } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovTasks(uint64(len(k))) + 1 + len(v) + sovTasks(uint64(len(v))) n += mapEntrySize + 1 + sovTasks(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MetricsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Filters) > 0 { for _, s := range m.Filters { l = len(s) n += 1 + l + sovTasks(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MetricsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Metrics) > 0 { for _, e := range m.Metrics { l = e.Size() n += 1 + l + sovTasks(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WaitRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } l = len(m.ExecID) if l > 0 { n += 1 + l + sovTasks(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WaitResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.ExitStatus != 0 { n += 1 + sovTasks(uint64(m.ExitStatus)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) n += 1 + l + sovTasks(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTasks(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozTasks(x uint64) (n int) { return sovTasks(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *CreateTaskRequest) String() string { if this == nil { return "nil" } repeatedStringForRootfs := "[]*Mount{" for _, f := range this.Rootfs { repeatedStringForRootfs += strings.Replace(fmt.Sprintf("%v", f), "Mount", "types.Mount", 1) + "," } repeatedStringForRootfs += "}" s := strings.Join([]string{`&CreateTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Rootfs:` + repeatedStringForRootfs + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, `Checkpoint:` + strings.Replace(fmt.Sprintf("%v", this.Checkpoint), "Descriptor", "types.Descriptor", 1) + `,`, `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CreateTaskResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateTaskResponse{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StartRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StartRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *StartResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StartResponse{`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteTaskRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteResponse{`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, `ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *DeleteProcessRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DeleteProcessRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *GetResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetResponse{`, `Process:` + strings.Replace(fmt.Sprintf("%v", this.Process), "Process", "task.Process", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListTasksRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListTasksRequest{`, `Filter:` + fmt.Sprintf("%v", this.Filter) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListTasksResponse) String() string { if this == nil { return "nil" } repeatedStringForTasks := "[]*Process{" for _, f := range this.Tasks { repeatedStringForTasks += strings.Replace(fmt.Sprintf("%v", f), "Process", "task.Process", 1) + "," } repeatedStringForTasks += "}" s := strings.Join([]string{`&ListTasksResponse{`, `Tasks:` + repeatedStringForTasks + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *KillRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&KillRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `Signal:` + fmt.Sprintf("%v", this.Signal) + `,`, `All:` + fmt.Sprintf("%v", this.All) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ExecProcessRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecProcessRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types1.Any", 1) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ExecProcessResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecProcessResponse{`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ResizePtyRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ResizePtyRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `Width:` + fmt.Sprintf("%v", this.Width) + `,`, `Height:` + fmt.Sprintf("%v", this.Height) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CloseIORequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CloseIORequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *PauseTaskRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PauseTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ResumeTaskRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ResumeTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListPidsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListPidsRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ListPidsResponse) String() string { if this == nil { return "nil" } repeatedStringForProcesses := "[]*ProcessInfo{" for _, f := range this.Processes { repeatedStringForProcesses += strings.Replace(fmt.Sprintf("%v", f), "ProcessInfo", "task.ProcessInfo", 1) + "," } repeatedStringForProcesses += "}" s := strings.Join([]string{`&ListPidsResponse{`, `Processes:` + repeatedStringForProcesses + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CheckpointTaskRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CheckpointTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`, `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *CheckpointTaskResponse) String() string { if this == nil { return "nil" } repeatedStringForDescriptors := "[]*Descriptor{" for _, f := range this.Descriptors { repeatedStringForDescriptors += strings.Replace(fmt.Sprintf("%v", f), "Descriptor", "types.Descriptor", 1) + "," } repeatedStringForDescriptors += "}" s := strings.Join([]string{`&CheckpointTaskResponse{`, `Descriptors:` + repeatedStringForDescriptors + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *UpdateTaskRequest) String() string { if this == nil { return "nil" } keysForAnnotations := make([]string, 0, len(this.Annotations)) for k, _ := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&UpdateTaskRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "types1.Any", 1) + `,`, `Annotations:` + mapStringForAnnotations + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *MetricsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&MetricsRequest{`, `Filters:` + fmt.Sprintf("%v", this.Filters) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *MetricsResponse) String() string { if this == nil { return "nil" } repeatedStringForMetrics := "[]*Metric{" for _, f := range this.Metrics { repeatedStringForMetrics += strings.Replace(fmt.Sprintf("%v", f), "Metric", "types.Metric", 1) + "," } repeatedStringForMetrics += "}" s := strings.Join([]string{`&MetricsResponse{`, `Metrics:` + repeatedStringForMetrics + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *WaitRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WaitRequest{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *WaitResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WaitResponse{`, `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, `ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringTasks(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Rootfs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Rootfs = append(m.Rootfs, &types.Mount{}) if err := m.Rootfs[len(m.Rootfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdin = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdout = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stderr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Terminal = bool(v != 0) case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Checkpoint == nil { m.Checkpoint = &types.Descriptor{} } if err := m.Checkpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Options == nil { m.Options = &types1.Any{} } if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CreateTaskResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CreateTaskResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StartRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StartRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StartRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *StartResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: StartResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StartResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) } m.ExitStatus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitStatus |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *DeleteProcessRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: DeleteProcessRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *GetResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: GetResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Process == nil { m.Process = &task.Process{} } if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListTasksRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListTasksRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListTasksRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Filter = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListTasksResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListTasksResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListTasksResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Tasks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Tasks = append(m.Tasks, &task.Process{}) if err := m.Tasks[len(m.Tasks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *KillRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: KillRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KillRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType) } m.Signal = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Signal |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field All", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.All = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ExecProcessRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ExecProcessRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdin = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdout = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Stderr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Terminal = bool(v != 0) case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Spec == nil { m.Spec = &types1.Any{} } if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ExecProcessResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResizePtyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResizePtyRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResizePtyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType) } m.Width = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Width |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) } m.Height = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Height |= uint32(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CloseIORequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CloseIORequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CloseIORequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Stdin = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PauseTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: PauseTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PauseTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ResumeTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ResumeTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResumeTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListPidsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListPidsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPidsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ListPidsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ListPidsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPidsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Processes = append(m.Processes, &task.ProcessInfo{}) if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CheckpointTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckpointTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ParentCheckpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ParentCheckpoint = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Options == nil { m.Options = &types1.Any{} } if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *CheckpointTaskResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: CheckpointTaskResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckpointTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Descriptors", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Descriptors = append(m.Descriptors, &types.Descriptor{}) if err := m.Descriptors[len(m.Descriptors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UpdateTaskRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UpdateTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Resources == nil { m.Resources = &types1.Any{} } if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if m.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthTasks } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthTasks } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthTasks } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthTasks } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *MetricsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: MetricsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Filters = append(m.Filters, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *MetricsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: MetricsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.Metrics = append(m.Metrics, &types.Metric{}) if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WaitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WaitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WaitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } m.ExecID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *WaitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: WaitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WaitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) } m.ExitStatus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitStatus |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTasks } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTasks } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTasks } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTasks } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipTasks(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTasks } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTasks } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTasks } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthTasks } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupTasks } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthTasks } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthTasks = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTasks = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupTasks = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/tasks/v1/tasks.proto000066400000000000000000000124561416535272200221540ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.tasks.v1; import "google/protobuf/empty.proto"; import "google/protobuf/any.proto"; import weak "gogoproto/gogo.proto"; import "github.com/containerd/containerd/api/types/mount.proto"; import "github.com/containerd/containerd/api/types/metrics.proto"; import "github.com/containerd/containerd/api/types/descriptor.proto"; import "github.com/containerd/containerd/api/types/task/task.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/services/tasks/v1;tasks"; service Tasks { // Create a task. rpc Create(CreateTaskRequest) returns (CreateTaskResponse); // Start a process. rpc Start(StartRequest) returns (StartResponse); // Delete a task and on disk state. rpc Delete(DeleteTaskRequest) returns (DeleteResponse); rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse); rpc Get(GetRequest) returns (GetResponse); rpc List(ListTasksRequest) returns (ListTasksResponse); // Kill a task or process. rpc Kill(KillRequest) returns (google.protobuf.Empty); rpc Exec(ExecProcessRequest) returns (google.protobuf.Empty); rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty); rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty); rpc Pause(PauseTaskRequest) returns (google.protobuf.Empty); rpc Resume(ResumeTaskRequest) returns (google.protobuf.Empty); rpc ListPids(ListPidsRequest) returns (ListPidsResponse); rpc Checkpoint(CheckpointTaskRequest) returns (CheckpointTaskResponse); rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty); rpc Metrics(MetricsRequest) returns (MetricsResponse); rpc Wait(WaitRequest) returns (WaitResponse); } message CreateTaskRequest { string container_id = 1; // RootFS provides the pre-chroot mounts to perform in the shim before // executing the container task. // // These are for mounts that cannot be performed in the user namespace. // Typically, these mounts should be resolved from snapshots specified on // the container object. repeated containerd.types.Mount rootfs = 3; string stdin = 4; string stdout = 5; string stderr = 6; bool terminal = 7; containerd.types.Descriptor checkpoint = 8; google.protobuf.Any options = 9; } message CreateTaskResponse { string container_id = 1; uint32 pid = 2; } message StartRequest { string container_id = 1; string exec_id = 2; } message StartResponse { uint32 pid = 1; } message DeleteTaskRequest { string container_id = 1; } message DeleteResponse { string id = 1; uint32 pid = 2; uint32 exit_status = 3; google.protobuf.Timestamp exited_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; } message DeleteProcessRequest { string container_id = 1; string exec_id = 2; } message GetRequest { string container_id = 1; string exec_id = 2; } message GetResponse { containerd.v1.types.Process process = 1; } message ListTasksRequest { string filter = 1; } message ListTasksResponse { repeated containerd.v1.types.Process tasks = 1; } message KillRequest { string container_id = 1; string exec_id = 2; uint32 signal = 3; bool all = 4; } message ExecProcessRequest { string container_id = 1; string stdin = 2; string stdout = 3; string stderr = 4; bool terminal = 5; // Spec for starting a process in the target container. // // For runc, this is a process spec, for example. google.protobuf.Any spec = 6; // id of the exec process string exec_id = 7; } message ExecProcessResponse { } message ResizePtyRequest { string container_id = 1; string exec_id = 2; uint32 width = 3; uint32 height = 4; } message CloseIORequest { string container_id = 1; string exec_id = 2; bool stdin = 3; } message PauseTaskRequest { string container_id = 1; } message ResumeTaskRequest { string container_id = 1; } message ListPidsRequest { string container_id = 1; } message ListPidsResponse { // Processes includes the process ID and additional process information repeated containerd.v1.types.ProcessInfo processes = 1; } message CheckpointTaskRequest { string container_id = 1; string parent_checkpoint = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; google.protobuf.Any options = 3; } message CheckpointTaskResponse { repeated containerd.types.Descriptor descriptors = 1; } message UpdateTaskRequest { string container_id = 1; google.protobuf.Any resources = 2; map annotations = 3; } message MetricsRequest { repeated string filters = 1; } message MetricsResponse { repeated types.Metric metrics = 1; } message WaitRequest { string container_id = 1; string exec_id = 2; } message WaitResponse { uint32 exit_status = 1; google.protobuf.Timestamp exited_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; } containerd-1.5.9/api/services/ttrpc/000077500000000000000000000000001416535272200174135ustar00rootroot00000000000000containerd-1.5.9/api/services/ttrpc/events/000077500000000000000000000000001416535272200207175ustar00rootroot00000000000000containerd-1.5.9/api/services/ttrpc/events/v1/000077500000000000000000000000001416535272200212455ustar00rootroot00000000000000containerd-1.5.9/api/services/ttrpc/events/v1/doc.go000066400000000000000000000012511416535272200223400ustar00rootroot00000000000000/* Copyright The containerd 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 events defines the event pushing and subscription service. package events containerd-1.5.9/api/services/ttrpc/events/v1/events.pb.go000066400000000000000000000475101416535272200235070ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/ttrpc/events/v1/events.proto package events import ( context "context" fmt "fmt" github_com_containerd_ttrpc "github.com/containerd/ttrpc" github_com_containerd_typeurl "github.com/containerd/typeurl" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type ForwardRequest struct { Envelope *Envelope `protobuf:"bytes,1,opt,name=envelope,proto3" json:"envelope,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ForwardRequest) Reset() { *m = ForwardRequest{} } func (*ForwardRequest) ProtoMessage() {} func (*ForwardRequest) Descriptor() ([]byte, []int) { return fileDescriptor_19f98672016720b5, []int{0} } func (m *ForwardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ForwardRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ForwardRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ForwardRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ForwardRequest.Merge(m, src) } func (m *ForwardRequest) XXX_Size() int { return m.Size() } func (m *ForwardRequest) XXX_DiscardUnknown() { xxx_messageInfo_ForwardRequest.DiscardUnknown(m) } var xxx_messageInfo_ForwardRequest proto.InternalMessageInfo type Envelope struct { Timestamp time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp"` Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"` Topic string `protobuf:"bytes,3,opt,name=topic,proto3" json:"topic,omitempty"` Event *types.Any `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Envelope) Reset() { *m = Envelope{} } func (*Envelope) ProtoMessage() {} func (*Envelope) Descriptor() ([]byte, []int) { return fileDescriptor_19f98672016720b5, []int{1} } func (m *Envelope) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Envelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Envelope.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Envelope) XXX_Merge(src proto.Message) { xxx_messageInfo_Envelope.Merge(m, src) } func (m *Envelope) XXX_Size() int { return m.Size() } func (m *Envelope) XXX_DiscardUnknown() { xxx_messageInfo_Envelope.DiscardUnknown(m) } var xxx_messageInfo_Envelope proto.InternalMessageInfo func init() { proto.RegisterType((*ForwardRequest)(nil), "containerd.services.events.ttrpc.v1.ForwardRequest") proto.RegisterType((*Envelope)(nil), "containerd.services.events.ttrpc.v1.Envelope") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/ttrpc/events/v1/events.proto", fileDescriptor_19f98672016720b5) } var fileDescriptor_19f98672016720b5 = []byte{ // 396 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x52, 0xc1, 0x8e, 0xd3, 0x30, 0x10, 0x8d, 0x61, 0x77, 0x69, 0x8d, 0xc4, 0xc1, 0xaa, 0x50, 0x08, 0x28, 0x59, 0x2d, 0x97, 0x15, 0x12, 0xb6, 0x76, 0xf7, 0x06, 0x17, 0xa8, 0x28, 0x12, 0x1c, 0x23, 0x84, 0x2a, 0x90, 0x10, 0x6e, 0x3a, 0x4d, 0x2d, 0x25, 0xb6, 0x49, 0x9c, 0xa0, 0xde, 0xfa, 0x09, 0x7c, 0x0c, 0x17, 0xfe, 0xa0, 0x47, 0x8e, 0x9c, 0x80, 0xe6, 0x4b, 0x50, 0x9d, 0xa4, 0x81, 0xf6, 0x40, 0xa5, 0xbd, 0xbd, 0xcc, 0x7b, 0x6f, 0xde, 0xcc, 0xc4, 0xf8, 0x75, 0x2c, 0xcc, 0xbc, 0x98, 0xd0, 0x48, 0xa5, 0x2c, 0x52, 0xd2, 0x70, 0x21, 0x21, 0x9b, 0xfe, 0x0d, 0xb9, 0x16, 0x2c, 0x87, 0xac, 0x14, 0x11, 0xe4, 0xcc, 0x98, 0x4c, 0x47, 0x0c, 0x4a, 0x90, 0x26, 0x67, 0xe5, 0x45, 0x83, 0xa8, 0xce, 0x94, 0x51, 0xe4, 0x61, 0xe7, 0xa2, 0xad, 0x83, 0x36, 0x0a, 0x6b, 0xa4, 0xe5, 0x85, 0xf7, 0xec, 0xbf, 0x81, 0xb6, 0xd9, 0xa4, 0x98, 0x31, 0x9d, 0x14, 0xb1, 0x90, 0x6c, 0x26, 0x20, 0x99, 0x6a, 0x6e, 0xe6, 0x75, 0x8c, 0x37, 0x88, 0x55, 0xac, 0x2c, 0x64, 0x1b, 0xd4, 0x54, 0xef, 0xc5, 0x4a, 0xc5, 0x09, 0x74, 0x6e, 0x2e, 0x17, 0x0d, 0x75, 0x7f, 0x97, 0x82, 0x54, 0x9b, 0x96, 0x0c, 0x76, 0x49, 0x23, 0x52, 0xc8, 0x0d, 0x4f, 0x75, 0x2d, 0x38, 0x7b, 0x8f, 0xef, 0xbc, 0x54, 0xd9, 0x67, 0x9e, 0x4d, 0x43, 0xf8, 0x54, 0x40, 0x6e, 0xc8, 0x2b, 0xdc, 0x03, 0x59, 0x42, 0xa2, 0x34, 0xb8, 0xe8, 0x14, 0x9d, 0xdf, 0xbe, 0x7c, 0x4c, 0x0f, 0x58, 0x9d, 0x8e, 0x1a, 0x53, 0xb8, 0xb5, 0x9f, 0x7d, 0x45, 0xb8, 0xd7, 0x96, 0xc9, 0x10, 0xf7, 0xb7, 0xe1, 0x4d, 0x63, 0x8f, 0xd6, 0xe3, 0xd1, 0x76, 0x3c, 0xfa, 0xa6, 0x55, 0x0c, 0x7b, 0xab, 0x9f, 0x81, 0xf3, 0xe5, 0x57, 0x80, 0xc2, 0xce, 0x46, 0x1e, 0xe0, 0xbe, 0xe4, 0x29, 0xe4, 0x9a, 0x47, 0xe0, 0xde, 0x38, 0x45, 0xe7, 0xfd, 0xb0, 0x2b, 0x90, 0x01, 0x3e, 0x36, 0x4a, 0x8b, 0xc8, 0xbd, 0x69, 0x99, 0xfa, 0x83, 0x3c, 0xc2, 0xc7, 0x76, 0x54, 0xf7, 0xc8, 0x66, 0x0e, 0xf6, 0x32, 0x9f, 0xcb, 0x45, 0x58, 0x4b, 0x9e, 0x1c, 0x2d, 0xbf, 0x05, 0xe8, 0xf2, 0x23, 0x3e, 0x19, 0xd9, 0xe5, 0xc8, 0x5b, 0x7c, 0xab, 0xb9, 0x0e, 0xb9, 0x3a, 0xe8, 0x08, 0xff, 0xde, 0xd2, 0xbb, 0xbb, 0x17, 0x36, 0xda, 0xfc, 0x9c, 0xe1, 0x87, 0xd5, 0xda, 0x77, 0x7e, 0xac, 0x7d, 0x67, 0x59, 0xf9, 0x68, 0x55, 0xf9, 0xe8, 0x7b, 0xe5, 0xa3, 0xdf, 0x95, 0x8f, 0xde, 0xbd, 0xb8, 0xd6, 0x8b, 0x7d, 0x5a, 0xa3, 0xb1, 0x33, 0x46, 0x93, 0x13, 0x9b, 0x79, 0xf5, 0x27, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x90, 0xbd, 0x09, 0x04, 0x03, 0x00, 0x00, } // Field returns the value for the given fieldpath as a string, if defined. // If the value is not defined, the second value will be false. func (m *Envelope) Field(fieldpath []string) (string, bool) { if len(fieldpath) == 0 { return "", false } switch fieldpath[0] { // unhandled: timestamp case "namespace": return string(m.Namespace), len(m.Namespace) > 0 case "topic": return string(m.Topic), len(m.Topic) > 0 case "event": decoded, err := github_com_containerd_typeurl.UnmarshalAny(m.Event) if err != nil { return "", false } adaptor, ok := decoded.(interface{ Field([]string) (string, bool) }) if !ok { return "", false } return adaptor.Field(fieldpath[1:]) } return "", false } func (m *ForwardRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ForwardRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ForwardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Envelope != nil { { size, err := m.Envelope.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Envelope) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Envelope) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Envelope) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Event != nil { { size, err := m.Event.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintEvents(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.Topic) > 0 { i -= len(m.Topic) copy(dAtA[i:], m.Topic) i = encodeVarintEvents(dAtA, i, uint64(len(m.Topic))) i-- dAtA[i] = 0x1a } if len(m.Namespace) > 0 { i -= len(m.Namespace) copy(dAtA[i:], m.Namespace) i = encodeVarintEvents(dAtA, i, uint64(len(m.Namespace))) i-- dAtA[i] = 0x12 } n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):]) if err3 != nil { return 0, err3 } i -= n3 i = encodeVarintEvents(dAtA, i, uint64(n3)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { offset -= sovEvents(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *ForwardRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Envelope != nil { l = m.Envelope.Size() n += 1 + l + sovEvents(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Envelope) Size() (n int) { if m == nil { return 0 } var l int _ = l l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp) n += 1 + l + sovEvents(uint64(l)) l = len(m.Namespace) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } l = len(m.Topic) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } if m.Event != nil { l = m.Event.Size() n += 1 + l + sovEvents(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovEvents(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozEvents(x uint64) (n int) { return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *ForwardRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ForwardRequest{`, `Envelope:` + strings.Replace(this.Envelope.String(), "Envelope", "Envelope", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *Envelope) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Envelope{`, `Timestamp:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, `Topic:` + fmt.Sprintf("%v", this.Topic) + `,`, `Event:` + strings.Replace(fmt.Sprintf("%v", this.Event), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringEvents(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } type EventsService interface { Forward(ctx context.Context, req *ForwardRequest) (*types.Empty, error) } func RegisterEventsService(srv *github_com_containerd_ttrpc.Server, svc EventsService) { srv.Register("containerd.services.events.ttrpc.v1.Events", map[string]github_com_containerd_ttrpc.Method{ "Forward": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { var req ForwardRequest if err := unmarshal(&req); err != nil { return nil, err } return svc.Forward(ctx, &req) }, }) } type eventsClient struct { client *github_com_containerd_ttrpc.Client } func NewEventsClient(client *github_com_containerd_ttrpc.Client) EventsService { return &eventsClient{ client: client, } } func (c *eventsClient) Forward(ctx context.Context, req *ForwardRequest) (*types.Empty, error) { var resp types.Empty if err := c.client.Call(ctx, "containerd.services.events.ttrpc.v1.Events", "Forward", req, &resp); err != nil { return nil, err } return &resp, nil } func (m *ForwardRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ForwardRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ForwardRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Envelope", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if m.Envelope == nil { m.Envelope = &Envelope{} } if err := m.Envelope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *Envelope) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Envelope: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Envelope: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Namespace = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } m.Topic = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEvents } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } if m.Event == nil { m.Event = &types.Any{} } if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthEvents } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipEvents(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEvents } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthEvents } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupEvents } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthEvents } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthEvents = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowEvents = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/ttrpc/events/v1/events.proto000066400000000000000000000030661416535272200236430ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.events.ttrpc.v1; import weak "github.com/containerd/containerd/protobuf/plugin/fieldpath.proto"; import weak "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/services/ttrpc/events/v1;events"; service Events { // Forward sends an event that has already been packaged into an envelope // with a timestamp and namespace. // // This is useful if earlier timestamping is required or when forwarding on // behalf of another component, namespace or publisher. rpc Forward(ForwardRequest) returns (google.protobuf.Empty); } message ForwardRequest { Envelope envelope = 1; } message Envelope { option (containerd.plugin.fieldpath) = true; google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; string namespace = 2; string topic = 3; google.protobuf.Any event = 4; } containerd-1.5.9/api/services/version/000077500000000000000000000000001416535272200177445ustar00rootroot00000000000000containerd-1.5.9/api/services/version/v1/000077500000000000000000000000001416535272200202725ustar00rootroot00000000000000containerd-1.5.9/api/services/version/v1/version.pb.go000066400000000000000000000315761416535272200227220ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/services/version/v1/version.proto package version import ( context "context" fmt "fmt" proto "github.com/gogo/protobuf/proto" types "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type VersionResponse struct { Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` Revision string `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *VersionResponse) Reset() { *m = VersionResponse{} } func (*VersionResponse) ProtoMessage() {} func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_128109001e578ffe, []int{0} } func (m *VersionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *VersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VersionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *VersionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_VersionResponse.Merge(m, src) } func (m *VersionResponse) XXX_Size() int { return m.Size() } func (m *VersionResponse) XXX_DiscardUnknown() { xxx_messageInfo_VersionResponse.DiscardUnknown(m) } var xxx_messageInfo_VersionResponse proto.InternalMessageInfo func init() { proto.RegisterType((*VersionResponse)(nil), "containerd.services.version.v1.VersionResponse") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/services/version/v1/version.proto", fileDescriptor_128109001e578ffe) } var fileDescriptor_128109001e578ffe = []byte{ // 243 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x72, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x16, 0xeb, 0x97, 0xa5, 0x16, 0x15, 0x67, 0xe6, 0xe7, 0xe9, 0x97, 0x19, 0xc2, 0x98, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x72, 0x08, 0x1d, 0x7a, 0x30, 0xd5, 0x7a, 0x30, 0x25, 0x65, 0x86, 0x52, 0xd2, 0xe9, 0xf9, 0xf9, 0xe9, 0x39, 0xa9, 0xfa, 0x60, 0xd5, 0x49, 0xa5, 0x69, 0xfa, 0xa9, 0xb9, 0x05, 0x25, 0x95, 0x10, 0xcd, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0xa6, 0x3e, 0x88, 0x05, 0x11, 0x55, 0x72, 0xe7, 0xe2, 0x0f, 0x83, 0x18, 0x10, 0x94, 0x5a, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0x2a, 0x24, 0xc1, 0xc5, 0x0e, 0x35, 0x53, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xc6, 0x15, 0x92, 0xe2, 0xe2, 0x28, 0x4a, 0x2d, 0xcb, 0x04, 0x4b, 0x31, 0x81, 0xa5, 0xe0, 0x7c, 0xa3, 0x58, 0x2e, 0x76, 0xa8, 0x41, 0x42, 0x41, 0x08, 0xa6, 0x98, 0x1e, 0xc4, 0x49, 0x7a, 0x30, 0x27, 0xe9, 0xb9, 0x82, 0x9c, 0x24, 0xa5, 0xaf, 0x87, 0xdf, 0x2b, 0x7a, 0x68, 0x8e, 0x72, 0x8a, 0x3a, 0xf1, 0x50, 0x8e, 0xe1, 0xc6, 0x43, 0x39, 0x86, 0x86, 0x47, 0x72, 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x63, 0x94, 0x03, 0xb9, 0x81, 0x6b, 0x0d, 0x65, 0x46, 0x30, 0x26, 0xb1, 0x81, 0x9d, 0x67, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x95, 0x0d, 0x52, 0x23, 0xa9, 0x01, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // VersionClient is the client API for Version service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type VersionClient interface { Version(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*VersionResponse, error) } type versionClient struct { cc *grpc.ClientConn } func NewVersionClient(cc *grpc.ClientConn) VersionClient { return &versionClient{cc} } func (c *versionClient) Version(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*VersionResponse, error) { out := new(VersionResponse) err := c.cc.Invoke(ctx, "/containerd.services.version.v1.Version/Version", in, out, opts...) if err != nil { return nil, err } return out, nil } // VersionServer is the server API for Version service. type VersionServer interface { Version(context.Context, *types.Empty) (*VersionResponse, error) } // UnimplementedVersionServer can be embedded to have forward compatible implementations. type UnimplementedVersionServer struct { } func (*UnimplementedVersionServer) Version(ctx context.Context, req *types.Empty) (*VersionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Version not implemented") } func RegisterVersionServer(s *grpc.Server, srv VersionServer) { s.RegisterService(&_Version_serviceDesc, srv) } func _Version_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(types.Empty) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(VersionServer).Version(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/containerd.services.version.v1.Version/Version", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(VersionServer).Version(ctx, req.(*types.Empty)) } return interceptor(ctx, in, info, handler) } var _Version_serviceDesc = grpc.ServiceDesc{ ServiceName: "containerd.services.version.v1.Version", HandlerType: (*VersionServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Version", Handler: _Version_Version_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "github.com/containerd/containerd/api/services/version/v1/version.proto", } func (m *VersionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *VersionResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *VersionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Revision) > 0 { i -= len(m.Revision) copy(dAtA[i:], m.Revision) i = encodeVarintVersion(dAtA, i, uint64(len(m.Revision))) i-- dAtA[i] = 0x12 } if len(m.Version) > 0 { i -= len(m.Version) copy(dAtA[i:], m.Version) i = encodeVarintVersion(dAtA, i, uint64(len(m.Version))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintVersion(dAtA []byte, offset int, v uint64) int { offset -= sovVersion(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *VersionResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Version) if l > 0 { n += 1 + l + sovVersion(uint64(l)) } l = len(m.Revision) if l > 0 { n += 1 + l + sovVersion(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovVersion(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozVersion(x uint64) (n int) { return sovVersion(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *VersionResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&VersionResponse{`, `Version:` + fmt.Sprintf("%v", this.Version) + `,`, `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringVersion(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *VersionResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowVersion } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: VersionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: VersionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowVersion } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthVersion } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthVersion } if postIndex > l { return io.ErrUnexpectedEOF } m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowVersion } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthVersion } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthVersion } if postIndex > l { return io.ErrUnexpectedEOF } m.Revision = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipVersion(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthVersion } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipVersion(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowVersion } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowVersion } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowVersion } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthVersion } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupVersion } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthVersion } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthVersion = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowVersion = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupVersion = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/services/version/v1/version.proto000066400000000000000000000017721416535272200230530ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.services.version.v1; import "google/protobuf/empty.proto"; import weak "gogoproto/gogo.proto"; // TODO(stevvooe): Should version service actually be versioned? option go_package = "github.com/containerd/containerd/api/services/version/v1;version"; service Version { rpc Version(google.protobuf.Empty) returns (VersionResponse); } message VersionResponse { string version = 1; string revision = 2; } containerd-1.5.9/api/types/000077500000000000000000000000001416535272200156005ustar00rootroot00000000000000containerd-1.5.9/api/types/descriptor.pb.go000066400000000000000000000405231416535272200207110ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/types/descriptor.proto package types import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" github_com_opencontainers_go_digest "github.com/opencontainers/go-digest" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Descriptor describes a blob in a content store. // // This descriptor can be used to reference content from an // oci descriptor found in a manifest. // See https://godoc.org/github.com/opencontainers/image-spec/specs-go/v1#Descriptor type Descriptor struct { MediaType string `protobuf:"bytes,1,opt,name=media_type,json=mediaType,proto3" json:"media_type,omitempty"` Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,2,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"` Size_ int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` Annotations map[string]string `protobuf:"bytes,5,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Descriptor) Reset() { *m = Descriptor{} } func (*Descriptor) ProtoMessage() {} func (*Descriptor) Descriptor() ([]byte, []int) { return fileDescriptor_37f958df3707db9e, []int{0} } func (m *Descriptor) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Descriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Descriptor.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Descriptor) XXX_Merge(src proto.Message) { xxx_messageInfo_Descriptor.Merge(m, src) } func (m *Descriptor) XXX_Size() int { return m.Size() } func (m *Descriptor) XXX_DiscardUnknown() { xxx_messageInfo_Descriptor.DiscardUnknown(m) } var xxx_messageInfo_Descriptor proto.InternalMessageInfo func init() { proto.RegisterType((*Descriptor)(nil), "containerd.types.Descriptor") proto.RegisterMapType((map[string]string)(nil), "containerd.types.Descriptor.AnnotationsEntry") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/types/descriptor.proto", fileDescriptor_37f958df3707db9e) } var fileDescriptor_37f958df3707db9e = []byte{ // 311 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xa7, 0xa4, 0x16, 0x27, 0x17, 0x65, 0x16, 0x94, 0xe4, 0x17, 0xe9, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x20, 0x94, 0xe9, 0x81, 0x95, 0x48, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf5, 0x41, 0x2c, 0x88, 0x3a, 0xa5, 0x39, 0x4c, 0x5c, 0x5c, 0x2e, 0x70, 0xcd, 0x42, 0xb2, 0x5c, 0x5c, 0xb9, 0xa9, 0x29, 0x99, 0x89, 0xf1, 0x20, 0x3d, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x9c, 0x60, 0x91, 0x90, 0xca, 0x82, 0x54, 0x21, 0x2f, 0x2e, 0xb6, 0x94, 0xcc, 0xf4, 0xd4, 0xe2, 0x12, 0x09, 0x26, 0x90, 0x94, 0x93, 0xd1, 0x89, 0x7b, 0xf2, 0x0c, 0xb7, 0xee, 0xc9, 0x6b, 0x21, 0x39, 0x35, 0xbf, 0x20, 0x35, 0x0f, 0x6e, 0x79, 0xb1, 0x7e, 0x7a, 0xbe, 0x2e, 0x44, 0x8b, 0x9e, 0x0b, 0x98, 0x0a, 0x82, 0x9a, 0x20, 0x24, 0xc4, 0xc5, 0x52, 0x9c, 0x59, 0x95, 0x2a, 0xc1, 0xac, 0xc0, 0xa8, 0xc1, 0x1c, 0x04, 0x66, 0x0b, 0xf9, 0x73, 0x71, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0x15, 0x4b, 0xb0, 0x2a, 0x30, 0x6b, 0x70, 0x1b, 0xe9, 0xea, 0xa1, 0xfb, 0x45, 0x0f, 0xe1, 0x62, 0x3d, 0x47, 0x84, 0x7a, 0xd7, 0xbc, 0x92, 0xa2, 0xca, 0x20, 0x64, 0x13, 0xa4, 0xec, 0xb8, 0x04, 0xd0, 0x15, 0x08, 0x09, 0x70, 0x31, 0x67, 0xa7, 0x56, 0x42, 0x3d, 0x07, 0x62, 0x0a, 0x89, 0x70, 0xb1, 0x96, 0x25, 0xe6, 0x94, 0xa6, 0x42, 0x7c, 0x15, 0x04, 0xe1, 0x58, 0x31, 0x59, 0x30, 0x3a, 0x79, 0x9d, 0x78, 0x28, 0xc7, 0x70, 0xe3, 0xa1, 0x1c, 0x43, 0xc3, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x31, 0xca, 0x80, 0xf8, 0xd8, 0xb1, 0x06, 0x93, 0x11, 0x0c, 0x49, 0x6c, 0xe0, 0x30, 0x37, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x22, 0x8a, 0x20, 0x4a, 0xda, 0x01, 0x00, 0x00, } func (m *Descriptor) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Descriptor) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Descriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintDescriptor(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintDescriptor(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintDescriptor(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x2a } } if m.Size_ != 0 { i = encodeVarintDescriptor(dAtA, i, uint64(m.Size_)) i-- dAtA[i] = 0x18 } if len(m.Digest) > 0 { i -= len(m.Digest) copy(dAtA[i:], m.Digest) i = encodeVarintDescriptor(dAtA, i, uint64(len(m.Digest))) i-- dAtA[i] = 0x12 } if len(m.MediaType) > 0 { i -= len(m.MediaType) copy(dAtA[i:], m.MediaType) i = encodeVarintDescriptor(dAtA, i, uint64(len(m.MediaType))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintDescriptor(dAtA []byte, offset int, v uint64) int { offset -= sovDescriptor(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Descriptor) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.MediaType) if l > 0 { n += 1 + l + sovDescriptor(uint64(l)) } l = len(m.Digest) if l > 0 { n += 1 + l + sovDescriptor(uint64(l)) } if m.Size_ != 0 { n += 1 + sovDescriptor(uint64(m.Size_)) } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovDescriptor(uint64(len(k))) + 1 + len(v) + sovDescriptor(uint64(len(v))) n += mapEntrySize + 1 + sovDescriptor(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovDescriptor(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozDescriptor(x uint64) (n int) { return sovDescriptor(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Descriptor) String() string { if this == nil { return "nil" } keysForAnnotations := make([]string, 0, len(this.Annotations)) for k, _ := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&Descriptor{`, `MediaType:` + fmt.Sprintf("%v", this.MediaType) + `,`, `Digest:` + fmt.Sprintf("%v", this.Digest) + `,`, `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, `Annotations:` + mapStringForAnnotations + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringDescriptor(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Descriptor) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Descriptor: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Descriptor: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MediaType", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthDescriptor } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthDescriptor } if postIndex > l { return io.ErrUnexpectedEOF } m.MediaType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthDescriptor } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthDescriptor } if postIndex > l { return io.ErrUnexpectedEOF } m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDescriptor } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthDescriptor } if postIndex > l { return io.ErrUnexpectedEOF } if m.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthDescriptor } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthDescriptor } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDescriptor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthDescriptor } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthDescriptor } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipDescriptor(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDescriptor } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDescriptor(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthDescriptor } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipDescriptor(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDescriptor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDescriptor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDescriptor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthDescriptor } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupDescriptor } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthDescriptor } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthDescriptor = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowDescriptor = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupDescriptor = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/types/descriptor.proto000066400000000000000000000022501416535272200210420ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.types; import weak "gogoproto/gogo.proto"; option go_package = "github.com/containerd/containerd/api/types;types"; // Descriptor describes a blob in a content store. // // This descriptor can be used to reference content from an // oci descriptor found in a manifest. // See https://godoc.org/github.com/opencontainers/image-spec/specs-go/v1#Descriptor message Descriptor { string media_type = 1; string digest = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false]; int64 size = 3; map annotations = 5; } containerd-1.5.9/api/types/doc.go000066400000000000000000000011421416535272200166720ustar00rootroot00000000000000/* Copyright The containerd 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 types containerd-1.5.9/api/types/metrics.pb.go000066400000000000000000000267341416535272200202110ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/types/metrics.proto package types import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Metric struct { Timestamp time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp"` ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` Data *types.Any `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Metric) Reset() { *m = Metric{} } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { return fileDescriptor_8d594d87edf6e6bc, []int{0} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Metric.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Metric) XXX_Merge(src proto.Message) { xxx_messageInfo_Metric.Merge(m, src) } func (m *Metric) XXX_Size() int { return m.Size() } func (m *Metric) XXX_DiscardUnknown() { xxx_messageInfo_Metric.DiscardUnknown(m) } var xxx_messageInfo_Metric proto.InternalMessageInfo func init() { proto.RegisterType((*Metric)(nil), "containerd.types.Metric") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/types/metrics.proto", fileDescriptor_8d594d87edf6e6bc) } var fileDescriptor_8d594d87edf6e6bc = []byte{ // 258 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x48, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xe7, 0xa6, 0x96, 0x14, 0x65, 0x26, 0x17, 0xeb, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x20, 0xd4, 0xe8, 0x81, 0xe5, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x92, 0xfa, 0x20, 0x16, 0x44, 0x9d, 0x94, 0x64, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x3e, 0x98, 0x97, 0x54, 0x9a, 0xa6, 0x9f, 0x98, 0x57, 0x09, 0x95, 0x92, 0x47, 0x97, 0x2a, 0xc9, 0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x80, 0x28, 0x50, 0xea, 0x63, 0xe4, 0x62, 0xf3, 0x05, 0xdb, 0x2a, 0xe4, 0xc4, 0xc5, 0x09, 0x97, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd2, 0x83, 0xe8, 0xd7, 0x83, 0xe9, 0xd7, 0x0b, 0x81, 0xa9, 0x70, 0xe2, 0x38, 0x71, 0x4f, 0x9e, 0x61, 0xc2, 0x7d, 0x79, 0xc6, 0x20, 0x84, 0x36, 0x21, 0x31, 0x2e, 0xa6, 0xcc, 0x14, 0x09, 0x26, 0x05, 0x46, 0x0d, 0x4e, 0x27, 0xb6, 0x47, 0xf7, 0xe4, 0x99, 0x3c, 0x5d, 0x82, 0x98, 0x32, 0x53, 0x84, 0x34, 0xb8, 0x58, 0x52, 0x12, 0x4b, 0x12, 0x25, 0x98, 0xc1, 0xc6, 0x8a, 0x60, 0x18, 0xeb, 0x98, 0x57, 0x19, 0x04, 0x56, 0xe1, 0xe4, 0x75, 0xe2, 0xa1, 0x1c, 0xc3, 0x8d, 0x87, 0x72, 0x0c, 0x0d, 0x8f, 0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x28, 0x03, 0xe2, 0x03, 0xd2, 0x1a, 0x4c, 0x46, 0x30, 0x24, 0xb1, 0x81, 0x6d, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xde, 0x0d, 0x02, 0xfe, 0x85, 0x01, 0x00, 0x00, } func (m *Metric) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Metric) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Data != nil { { size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintMetrics(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintMetrics(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0x12 } n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):]) if err2 != nil { return 0, err2 } i -= n2 i = encodeVarintMetrics(dAtA, i, uint64(n2)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func encodeVarintMetrics(dAtA []byte, offset int, v uint64) int { offset -= sovMetrics(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Metric) Size() (n int) { if m == nil { return 0 } var l int _ = l l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp) n += 1 + l + sovMetrics(uint64(l)) l = len(m.ID) if l > 0 { n += 1 + l + sovMetrics(uint64(l)) } if m.Data != nil { l = m.Data.Size() n += 1 + l + sovMetrics(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovMetrics(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozMetrics(x uint64) (n int) { return sovMetrics(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Metric) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Metric{`, `Timestamp:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Data:` + strings.Replace(fmt.Sprintf("%v", this.Data), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringMetrics(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Metric) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetrics } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Metric: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Metric: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetrics } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetrics } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthMetrics } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetrics } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthMetrics } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthMetrics } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetrics } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetrics } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthMetrics } if postIndex > l { return io.ErrUnexpectedEOF } if m.Data == nil { m.Data = &types.Any{} } if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMetrics(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthMetrics } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipMetrics(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetrics } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetrics } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetrics } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthMetrics } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupMetrics } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthMetrics } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthMetrics = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowMetrics = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupMetrics = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/types/metrics.proto000066400000000000000000000017171416535272200203410ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.types; import weak "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/containerd/containerd/api/types;types"; message Metric { google.protobuf.Timestamp timestamp = 1 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; string id = 2; google.protobuf.Any data = 3; } containerd-1.5.9/api/types/mount.pb.go000066400000000000000000000304121416535272200176710ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/types/mount.proto package types import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Mount describes mounts for a container. // // This type is the lingua franca of ContainerD. All services provide mounts // to be used with the container at creation time. // // The Mount type follows the structure of the mount syscall, including a type, // source, target and options. type Mount struct { // Type defines the nature of the mount. Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` // Source specifies the name of the mount. Depending on mount type, this // may be a volume name or a host path, or even ignored. Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` // Target path in container Target string `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"` // Options specifies zero or more fstab style mount options. Options []string `protobuf:"bytes,4,rep,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Mount) Reset() { *m = Mount{} } func (*Mount) ProtoMessage() {} func (*Mount) Descriptor() ([]byte, []int) { return fileDescriptor_920196890d4a7b9f, []int{0} } func (m *Mount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Mount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Mount.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Mount) XXX_Merge(src proto.Message) { xxx_messageInfo_Mount.Merge(m, src) } func (m *Mount) XXX_Size() int { return m.Size() } func (m *Mount) XXX_DiscardUnknown() { xxx_messageInfo_Mount.DiscardUnknown(m) } var xxx_messageInfo_Mount proto.InternalMessageInfo func init() { proto.RegisterType((*Mount)(nil), "containerd.types.Mount") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/types/mount.proto", fileDescriptor_920196890d4a7b9f) } var fileDescriptor_920196890d4a7b9f = []byte{ // 202 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0xe7, 0xe6, 0x97, 0xe6, 0x95, 0xe8, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x20, 0x54, 0xe8, 0x81, 0x65, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x92, 0xfa, 0x20, 0x16, 0x44, 0x9d, 0x52, 0x2a, 0x17, 0xab, 0x2f, 0x48, 0x9b, 0x90, 0x10, 0x17, 0x0b, 0x48, 0x9d, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x98, 0x2d, 0x24, 0xc6, 0xc5, 0x56, 0x9c, 0x5f, 0x5a, 0x94, 0x9c, 0x2a, 0xc1, 0x04, 0x16, 0x85, 0xf2, 0x40, 0xe2, 0x25, 0x89, 0x45, 0xe9, 0xa9, 0x25, 0x12, 0xcc, 0x10, 0x71, 0x08, 0x4f, 0x48, 0x82, 0x8b, 0x3d, 0xbf, 0xa0, 0x24, 0x33, 0x3f, 0xaf, 0x58, 0x82, 0x45, 0x81, 0x59, 0x83, 0x33, 0x08, 0xc6, 0x75, 0xf2, 0x3a, 0xf1, 0x50, 0x8e, 0xe1, 0xc6, 0x43, 0x39, 0x86, 0x86, 0x47, 0x72, 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x63, 0x94, 0x01, 0xf1, 0x1e, 0xb4, 0x06, 0x93, 0x11, 0x0c, 0x49, 0x6c, 0x60, 0xb7, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x82, 0x1c, 0x02, 0x18, 0x1d, 0x01, 0x00, 0x00, } func (m *Mount) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Mount) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Options) > 0 { for iNdEx := len(m.Options) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Options[iNdEx]) copy(dAtA[i:], m.Options[iNdEx]) i = encodeVarintMount(dAtA, i, uint64(len(m.Options[iNdEx]))) i-- dAtA[i] = 0x22 } } if len(m.Target) > 0 { i -= len(m.Target) copy(dAtA[i:], m.Target) i = encodeVarintMount(dAtA, i, uint64(len(m.Target))) i-- dAtA[i] = 0x1a } if len(m.Source) > 0 { i -= len(m.Source) copy(dAtA[i:], m.Source) i = encodeVarintMount(dAtA, i, uint64(len(m.Source))) i-- dAtA[i] = 0x12 } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = encodeVarintMount(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintMount(dAtA []byte, offset int, v uint64) int { offset -= sovMount(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Mount) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Type) if l > 0 { n += 1 + l + sovMount(uint64(l)) } l = len(m.Source) if l > 0 { n += 1 + l + sovMount(uint64(l)) } l = len(m.Target) if l > 0 { n += 1 + l + sovMount(uint64(l)) } if len(m.Options) > 0 { for _, s := range m.Options { l = len(s) n += 1 + l + sovMount(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovMount(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozMount(x uint64) (n int) { return sovMount(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Mount) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Mount{`, `Type:` + fmt.Sprintf("%v", this.Type) + `,`, `Source:` + fmt.Sprintf("%v", this.Source) + `,`, `Target:` + fmt.Sprintf("%v", this.Target) + `,`, `Options:` + fmt.Sprintf("%v", this.Options) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringMount(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Mount) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMount } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Mount: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Mount: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMount } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthMount } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthMount } if postIndex > l { return io.ErrUnexpectedEOF } m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMount } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthMount } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthMount } if postIndex > l { return io.ErrUnexpectedEOF } m.Source = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMount } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthMount } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthMount } if postIndex > l { return io.ErrUnexpectedEOF } m.Target = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMount } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthMount } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthMount } if postIndex > l { return io.ErrUnexpectedEOF } m.Options = append(m.Options, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMount(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthMount } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipMount(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMount } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMount } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMount } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthMount } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupMount } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthMount } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthMount = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowMount = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupMount = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/types/mount.proto000066400000000000000000000025601416535272200200320ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.types; import weak "gogoproto/gogo.proto"; option go_package = "github.com/containerd/containerd/api/types;types"; // Mount describes mounts for a container. // // This type is the lingua franca of ContainerD. All services provide mounts // to be used with the container at creation time. // // The Mount type follows the structure of the mount syscall, including a type, // source, target and options. message Mount { // Type defines the nature of the mount. string type = 1; // Source specifies the name of the mount. Depending on mount type, this // may be a volume name or a host path, or even ignored. string source = 2; // Target path in container string target = 3; // Options specifies zero or more fstab style mount options. repeated string options = 4; } containerd-1.5.9/api/types/platform.pb.go000066400000000000000000000255761416535272200203720ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/types/platform.proto package types import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Platform follows the structure of the OCI platform specification, from // descriptors. type Platform struct { OS string `protobuf:"bytes,1,opt,name=os,proto3" json:"os,omitempty"` Architecture string `protobuf:"bytes,2,opt,name=architecture,proto3" json:"architecture,omitempty"` Variant string `protobuf:"bytes,3,opt,name=variant,proto3" json:"variant,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Platform) Reset() { *m = Platform{} } func (*Platform) ProtoMessage() {} func (*Platform) Descriptor() ([]byte, []int) { return fileDescriptor_24ba7a4b83e2367e, []int{0} } func (m *Platform) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Platform) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Platform.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Platform) XXX_Merge(src proto.Message) { xxx_messageInfo_Platform.Merge(m, src) } func (m *Platform) XXX_Size() int { return m.Size() } func (m *Platform) XXX_DiscardUnknown() { xxx_messageInfo_Platform.DiscardUnknown(m) } var xxx_messageInfo_Platform proto.InternalMessageInfo func init() { proto.RegisterType((*Platform)(nil), "containerd.types.Platform") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/types/platform.proto", fileDescriptor_24ba7a4b83e2367e) } var fileDescriptor_24ba7a4b83e2367e = []byte{ // 205 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x4a, 0x41, 0x66, 0x26, 0x16, 0x64, 0xea, 0x97, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0x17, 0xe4, 0x24, 0x96, 0xa4, 0xe5, 0x17, 0xe5, 0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x20, 0x14, 0xe9, 0x81, 0x15, 0x48, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf5, 0x41, 0x2c, 0x88, 0x3a, 0xa5, 0x04, 0x2e, 0x8e, 0x00, 0xa8, 0x4e, 0x21, 0x31, 0x2e, 0xa6, 0xfc, 0x62, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x4e, 0x27, 0xb6, 0x47, 0xf7, 0xe4, 0x99, 0xfc, 0x83, 0x83, 0x98, 0xf2, 0x8b, 0x85, 0x94, 0xb8, 0x78, 0x12, 0x8b, 0x92, 0x33, 0x32, 0x4b, 0x52, 0x93, 0x4b, 0x4a, 0x8b, 0x52, 0x25, 0x98, 0x40, 0x2a, 0x82, 0x50, 0xc4, 0x84, 0x24, 0xb8, 0xd8, 0xcb, 0x12, 0x8b, 0x32, 0x13, 0xf3, 0x4a, 0x24, 0x98, 0xc1, 0xd2, 0x30, 0xae, 0x93, 0xd7, 0x89, 0x87, 0x72, 0x0c, 0x37, 0x1e, 0xca, 0x31, 0x34, 0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0xa3, 0x0c, 0x88, 0xf7, 0x9e, 0x35, 0x98, 0x8c, 0x60, 0x48, 0x62, 0x03, 0x3b, 0xdb, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x05, 0xaa, 0xda, 0xa1, 0x1b, 0x01, 0x00, 0x00, } func (m *Platform) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Platform) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Platform) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Variant) > 0 { i -= len(m.Variant) copy(dAtA[i:], m.Variant) i = encodeVarintPlatform(dAtA, i, uint64(len(m.Variant))) i-- dAtA[i] = 0x1a } if len(m.Architecture) > 0 { i -= len(m.Architecture) copy(dAtA[i:], m.Architecture) i = encodeVarintPlatform(dAtA, i, uint64(len(m.Architecture))) i-- dAtA[i] = 0x12 } if len(m.OS) > 0 { i -= len(m.OS) copy(dAtA[i:], m.OS) i = encodeVarintPlatform(dAtA, i, uint64(len(m.OS))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func encodeVarintPlatform(dAtA []byte, offset int, v uint64) int { offset -= sovPlatform(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Platform) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.OS) if l > 0 { n += 1 + l + sovPlatform(uint64(l)) } l = len(m.Architecture) if l > 0 { n += 1 + l + sovPlatform(uint64(l)) } l = len(m.Variant) if l > 0 { n += 1 + l + sovPlatform(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovPlatform(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozPlatform(x uint64) (n int) { return sovPlatform(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Platform) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Platform{`, `OS:` + fmt.Sprintf("%v", this.OS) + `,`, `Architecture:` + fmt.Sprintf("%v", this.Architecture) + `,`, `Variant:` + fmt.Sprintf("%v", this.Variant) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringPlatform(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Platform) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlatform } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Platform: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Platform: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OS", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlatform } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthPlatform } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlatform } if postIndex > l { return io.ErrUnexpectedEOF } m.OS = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Architecture", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlatform } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthPlatform } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlatform } if postIndex > l { return io.ErrUnexpectedEOF } m.Architecture = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Variant", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlatform } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthPlatform } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlatform } if postIndex > l { return io.ErrUnexpectedEOF } m.Variant = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPlatform(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPlatform } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipPlatform(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPlatform } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPlatform } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPlatform } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthPlatform } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupPlatform } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthPlatform } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthPlatform = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowPlatform = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupPlatform = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/types/platform.proto000066400000000000000000000016501416535272200205130ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.types; import weak "gogoproto/gogo.proto"; option go_package = "github.com/containerd/containerd/api/types;types"; // Platform follows the structure of the OCI platform specification, from // descriptors. message Platform { string os = 1 [(gogoproto.customname) = "OS"]; string architecture = 2; string variant = 3; } containerd-1.5.9/api/types/task/000077500000000000000000000000001416535272200165425ustar00rootroot00000000000000containerd-1.5.9/api/types/task/task.pb.go000066400000000000000000000615621416535272200204450ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: github.com/containerd/containerd/api/types/task/task.proto package task import ( fmt "fmt" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/gogo/protobuf/types" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Status int32 const ( StatusUnknown Status = 0 StatusCreated Status = 1 StatusRunning Status = 2 StatusStopped Status = 3 StatusPaused Status = 4 StatusPausing Status = 5 ) var Status_name = map[int32]string{ 0: "UNKNOWN", 1: "CREATED", 2: "RUNNING", 3: "STOPPED", 4: "PAUSED", 5: "PAUSING", } var Status_value = map[string]int32{ "UNKNOWN": 0, "CREATED": 1, "RUNNING": 2, "STOPPED": 3, "PAUSED": 4, "PAUSING": 5, } func (x Status) String() string { return proto.EnumName(Status_name, int32(x)) } func (Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor_391ef18c8ab0dc16, []int{0} } type Process struct { ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` ID string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"` Status Status `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"` Stdin string `protobuf:"bytes,5,opt,name=stdin,proto3" json:"stdin,omitempty"` Stdout string `protobuf:"bytes,6,opt,name=stdout,proto3" json:"stdout,omitempty"` Stderr string `protobuf:"bytes,7,opt,name=stderr,proto3" json:"stderr,omitempty"` Terminal bool `protobuf:"varint,8,opt,name=terminal,proto3" json:"terminal,omitempty"` ExitStatus uint32 `protobuf:"varint,9,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` ExitedAt time.Time `protobuf:"bytes,10,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Process) Reset() { *m = Process{} } func (*Process) ProtoMessage() {} func (*Process) Descriptor() ([]byte, []int) { return fileDescriptor_391ef18c8ab0dc16, []int{0} } func (m *Process) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Process) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Process.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Process) XXX_Merge(src proto.Message) { xxx_messageInfo_Process.Merge(m, src) } func (m *Process) XXX_Size() int { return m.Size() } func (m *Process) XXX_DiscardUnknown() { xxx_messageInfo_Process.DiscardUnknown(m) } var xxx_messageInfo_Process proto.InternalMessageInfo type ProcessInfo struct { // PID is the process ID. Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` // Info contains additional process information. // // Info varies by platform. Info *types.Any `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ProcessInfo) Reset() { *m = ProcessInfo{} } func (*ProcessInfo) ProtoMessage() {} func (*ProcessInfo) Descriptor() ([]byte, []int) { return fileDescriptor_391ef18c8ab0dc16, []int{1} } func (m *ProcessInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ProcessInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ProcessInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *ProcessInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_ProcessInfo.Merge(m, src) } func (m *ProcessInfo) XXX_Size() int { return m.Size() } func (m *ProcessInfo) XXX_DiscardUnknown() { xxx_messageInfo_ProcessInfo.DiscardUnknown(m) } var xxx_messageInfo_ProcessInfo proto.InternalMessageInfo func init() { proto.RegisterEnum("containerd.v1.types.Status", Status_name, Status_value) proto.RegisterType((*Process)(nil), "containerd.v1.types.Process") proto.RegisterType((*ProcessInfo)(nil), "containerd.v1.types.ProcessInfo") } func init() { proto.RegisterFile("github.com/containerd/containerd/api/types/task/task.proto", fileDescriptor_391ef18c8ab0dc16) } var fileDescriptor_391ef18c8ab0dc16 = []byte{ // 545 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x3f, 0x6f, 0xd3, 0x40, 0x18, 0xc6, 0x7d, 0x6e, 0xeb, 0xa6, 0xe7, 0xb6, 0x18, 0x13, 0x55, 0xc6, 0x20, 0xdb, 0xea, 0x64, 0x31, 0xd8, 0x22, 0xdd, 0xd8, 0xf2, 0x4f, 0xc8, 0x42, 0x72, 0x23, 0x27, 0x11, 0x6c, 0x91, 0x13, 0x5f, 0xcc, 0xa9, 0xcd, 0x9d, 0x65, 0x9f, 0x81, 0x6c, 0x8c, 0xa8, 0x13, 0x5f, 0xa0, 0x13, 0x7c, 0x0a, 0x3e, 0x41, 0x46, 0x26, 0xc4, 0x14, 0xa8, 0x3f, 0x09, 0x3a, 0xdb, 0x49, 0x23, 0x60, 0x39, 0xbd, 0xef, 0xf3, 0x7b, 0xee, 0xbd, 0xf7, 0x1e, 0xf8, 0x22, 0xc6, 0xec, 0x6d, 0x3e, 0x75, 0x66, 0x74, 0xe1, 0xce, 0x28, 0x61, 0x21, 0x26, 0x28, 0x8d, 0x76, 0xcb, 0x30, 0xc1, 0x2e, 0x5b, 0x26, 0x28, 0x73, 0x59, 0x98, 0x5d, 0x95, 0x87, 0x93, 0xa4, 0x94, 0x51, 0xf5, 0xd1, 0xbd, 0xcb, 0x79, 0xf7, 0xdc, 0x29, 0x4d, 0x7a, 0x33, 0xa6, 0x31, 0x2d, 0xb9, 0xcb, 0xab, 0xca, 0xaa, 0x9b, 0x31, 0xa5, 0xf1, 0x35, 0x72, 0xcb, 0x6e, 0x9a, 0xcf, 0x5d, 0x86, 0x17, 0x28, 0x63, 0xe1, 0x22, 0xa9, 0x0d, 0x8f, 0xff, 0x36, 0x84, 0x64, 0x59, 0xa1, 0xf3, 0x42, 0x84, 0x87, 0x83, 0x94, 0xce, 0x50, 0x96, 0xa9, 0x2d, 0x78, 0xbc, 0x7d, 0x74, 0x82, 0x23, 0x0d, 0x58, 0xc0, 0x3e, 0xea, 0x3c, 0x28, 0xd6, 0xa6, 0xdc, 0xdd, 0xe8, 0x5e, 0x2f, 0x90, 0xb7, 0x26, 0x2f, 0x52, 0xcf, 0xa0, 0x88, 0x23, 0x4d, 0x2c, 0x9d, 0x52, 0xb1, 0x36, 0x45, 0xaf, 0x17, 0x88, 0x38, 0x52, 0x15, 0xb8, 0x97, 0xe0, 0x48, 0xdb, 0xb3, 0x80, 0x7d, 0x12, 0xf0, 0x52, 0xbd, 0x80, 0x52, 0xc6, 0x42, 0x96, 0x67, 0xda, 0xbe, 0x05, 0xec, 0xd3, 0xd6, 0x13, 0xe7, 0x3f, 0x3f, 0x74, 0x86, 0xa5, 0x25, 0xa8, 0xad, 0x6a, 0x13, 0x1e, 0x64, 0x2c, 0xc2, 0x44, 0x3b, 0xe0, 0x2f, 0x04, 0x55, 0xa3, 0x9e, 0xf1, 0x51, 0x11, 0xcd, 0x99, 0x26, 0x95, 0x72, 0xdd, 0xd5, 0x3a, 0x4a, 0x53, 0xed, 0x70, 0xab, 0xa3, 0x34, 0x55, 0x75, 0xd8, 0x60, 0x28, 0x5d, 0x60, 0x12, 0x5e, 0x6b, 0x0d, 0x0b, 0xd8, 0x8d, 0x60, 0xdb, 0xab, 0x26, 0x94, 0xd1, 0x07, 0xcc, 0x26, 0xf5, 0x6e, 0x47, 0xe5, 0xc2, 0x90, 0x4b, 0xd5, 0x2a, 0x6a, 0x1b, 0x1e, 0xf1, 0x0e, 0x45, 0x93, 0x90, 0x69, 0xd0, 0x02, 0xb6, 0xdc, 0xd2, 0x9d, 0x2a, 0x50, 0x67, 0x13, 0xa8, 0x33, 0xda, 0x24, 0xde, 0x69, 0xac, 0xd6, 0xa6, 0xf0, 0xf9, 0x97, 0x09, 0x82, 0x46, 0x75, 0xad, 0xcd, 0xce, 0x3d, 0x28, 0xd7, 0x19, 0x7b, 0x64, 0x4e, 0x37, 0xd9, 0x80, 0xfb, 0x6c, 0x6c, 0xb8, 0x8f, 0xc9, 0x9c, 0x96, 0x39, 0xca, 0xad, 0xe6, 0x3f, 0xe3, 0xdb, 0x64, 0x19, 0x94, 0x8e, 0x67, 0x3f, 0x00, 0x94, 0xea, 0xc5, 0x0c, 0x78, 0x38, 0xf6, 0x5f, 0xf9, 0x97, 0xaf, 0x7d, 0x45, 0xd0, 0x1f, 0xde, 0xdc, 0x5a, 0x27, 0x15, 0x18, 0x93, 0x2b, 0x42, 0xdf, 0x13, 0xce, 0xbb, 0x41, 0xbf, 0x3d, 0xea, 0xf7, 0x14, 0xb0, 0xcb, 0xbb, 0x29, 0x0a, 0x19, 0x8a, 0x38, 0x0f, 0xc6, 0xbe, 0xef, 0xf9, 0x2f, 0x15, 0x71, 0x97, 0x07, 0x39, 0x21, 0x98, 0xc4, 0x9c, 0x0f, 0x47, 0x97, 0x83, 0x41, 0xbf, 0xa7, 0xec, 0xed, 0xf2, 0x21, 0xa3, 0x49, 0x82, 0x22, 0xf5, 0x29, 0x94, 0x06, 0xed, 0xf1, 0xb0, 0xdf, 0x53, 0xf6, 0x75, 0xe5, 0xe6, 0xd6, 0x3a, 0xae, 0xf0, 0x20, 0xcc, 0xb3, 0x6a, 0x3a, 0xa7, 0x7c, 0xfa, 0xc1, 0xee, 0x6d, 0x8e, 0x31, 0x89, 0xf5, 0xd3, 0x4f, 0x5f, 0x0c, 0xe1, 0xdb, 0x57, 0xa3, 0xfe, 0x4d, 0x47, 0x5b, 0xdd, 0x19, 0xc2, 0xcf, 0x3b, 0x43, 0xf8, 0x58, 0x18, 0x60, 0x55, 0x18, 0xe0, 0x7b, 0x61, 0x80, 0xdf, 0x85, 0x01, 0xde, 0x08, 0x53, 0xa9, 0x0c, 0xe2, 0xe2, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x32, 0xd2, 0x86, 0x50, 0x03, 0x00, 0x00, } func (m *Process) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Process) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Process) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt):]) if err1 != nil { return 0, err1 } i -= n1 i = encodeVarintTask(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x52 if m.ExitStatus != 0 { i = encodeVarintTask(dAtA, i, uint64(m.ExitStatus)) i-- dAtA[i] = 0x48 } if m.Terminal { i-- if m.Terminal { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x40 } if len(m.Stderr) > 0 { i -= len(m.Stderr) copy(dAtA[i:], m.Stderr) i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr))) i-- dAtA[i] = 0x3a } if len(m.Stdout) > 0 { i -= len(m.Stdout) copy(dAtA[i:], m.Stdout) i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout))) i-- dAtA[i] = 0x32 } if len(m.Stdin) > 0 { i -= len(m.Stdin) copy(dAtA[i:], m.Stdin) i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin))) i-- dAtA[i] = 0x2a } if m.Status != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Status)) i-- dAtA[i] = 0x20 } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x18 } if len(m.ID) > 0 { i -= len(m.ID) copy(dAtA[i:], m.ID) i = encodeVarintTask(dAtA, i, uint64(len(m.ID))) i-- dAtA[i] = 0x12 } if len(m.ContainerID) > 0 { i -= len(m.ContainerID) copy(dAtA[i:], m.ContainerID) i = encodeVarintTask(dAtA, i, uint64(len(m.ContainerID))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ProcessInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ProcessInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ProcessInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.Info != nil { { size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintTask(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Pid != 0 { i = encodeVarintTask(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func encodeVarintTask(dAtA []byte, offset int, v uint64) int { offset -= sovTask(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Process) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.ID) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.Status != 0 { n += 1 + sovTask(uint64(m.Status)) } l = len(m.Stdin) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Stdout) if l > 0 { n += 1 + l + sovTask(uint64(l)) } l = len(m.Stderr) if l > 0 { n += 1 + l + sovTask(uint64(l)) } if m.Terminal { n += 2 } if m.ExitStatus != 0 { n += 1 + sovTask(uint64(m.ExitStatus)) } l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) n += 1 + l + sovTask(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ProcessInfo) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Pid != 0 { n += 1 + sovTask(uint64(m.Pid)) } if m.Info != nil { l = m.Info.Size() n += 1 + l + sovTask(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTask(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozTask(x uint64) (n int) { return sovTask(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *Process) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Process{`, `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, `ID:` + fmt.Sprintf("%v", this.ID) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `Status:` + fmt.Sprintf("%v", this.Status) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, `ExitedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ExitedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func (this *ProcessInfo) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ProcessInfo{`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `Info:` + strings.Replace(fmt.Sprintf("%v", this.Info), "Any", "types.Any", 1) + `,`, `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, `}`, }, "") return s } func valueToStringTask(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *Process) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: Process: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Process: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ContainerID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.ID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } m.Status = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Status |= Status(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdin = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdout = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } m.Stderr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.Terminal = bool(v != 0) case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) } m.ExitStatus = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitStatus |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *ProcessInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: ProcessInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ProcessInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTask } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTask } postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTask } if postIndex > l { return io.ErrUnexpectedEOF } if m.Info == nil { m.Info = &types.Any{} } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTask(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTask } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipTask(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTask } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthTask } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupTask } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthTask } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthTask = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTask = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupTask = fmt.Errorf("proto: unexpected end of group") ) containerd-1.5.9/api/types/task/task.proto000066400000000000000000000033151416535272200205730ustar00rootroot00000000000000/* Copyright The containerd 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. */ syntax = "proto3"; package containerd.v1.types; import weak "gogoproto/gogo.proto"; import "google/protobuf/timestamp.proto"; import "google/protobuf/any.proto"; enum Status { option (gogoproto.goproto_enum_prefix) = false; option (gogoproto.enum_customname) = "Status"; UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "StatusUnknown"]; CREATED = 1 [(gogoproto.enumvalue_customname) = "StatusCreated"]; RUNNING = 2 [(gogoproto.enumvalue_customname) = "StatusRunning"]; STOPPED = 3 [(gogoproto.enumvalue_customname) = "StatusStopped"]; PAUSED = 4 [(gogoproto.enumvalue_customname) = "StatusPaused"]; PAUSING = 5 [(gogoproto.enumvalue_customname) = "StatusPausing"]; } message Process { string container_id = 1; string id = 2; uint32 pid = 3; Status status = 4; string stdin = 5; string stdout = 6; string stderr = 7; bool terminal = 8; uint32 exit_status = 9; google.protobuf.Timestamp exited_at = 10 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; } message ProcessInfo { // PID is the process ID. uint32 pid = 1; // Info contains additional process information. // // Info varies by platform. google.protobuf.Any info = 2; } containerd-1.5.9/archive/000077500000000000000000000000001416535272200153045ustar00rootroot00000000000000containerd-1.5.9/archive/compression/000077500000000000000000000000001416535272200176455ustar00rootroot00000000000000containerd-1.5.9/archive/compression/compression.go000066400000000000000000000144171416535272200225440ustar00rootroot00000000000000/* Copyright The containerd 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 compression import ( "bufio" "bytes" "compress/gzip" "context" "fmt" "io" "os" "os/exec" "strconv" "sync" "github.com/containerd/containerd/log" "github.com/klauspost/compress/zstd" ) type ( // Compression is the state represents if compressed or not. Compression int ) const ( // Uncompressed represents the uncompressed. Uncompressed Compression = iota // Gzip is gzip compression algorithm. Gzip // Zstd is zstd compression algorithm. Zstd ) const disablePigzEnv = "CONTAINERD_DISABLE_PIGZ" var ( initPigz sync.Once unpigzPath string ) var ( bufioReader32KPool = &sync.Pool{ New: func() interface{} { return bufio.NewReaderSize(nil, 32*1024) }, } ) // DecompressReadCloser include the stream after decompress and the compress method detected. type DecompressReadCloser interface { io.ReadCloser // GetCompression returns the compress method which is used before decompressing GetCompression() Compression } type readCloserWrapper struct { io.Reader compression Compression closer func() error } func (r *readCloserWrapper) Close() error { if r.closer != nil { return r.closer() } return nil } func (r *readCloserWrapper) GetCompression() Compression { return r.compression } type writeCloserWrapper struct { io.Writer closer func() error } func (w *writeCloserWrapper) Close() error { if w.closer != nil { w.closer() } return nil } type bufferedReader struct { buf *bufio.Reader } func newBufferedReader(r io.Reader) *bufferedReader { buf := bufioReader32KPool.Get().(*bufio.Reader) buf.Reset(r) return &bufferedReader{buf} } func (r *bufferedReader) Read(p []byte) (n int, err error) { if r.buf == nil { return 0, io.EOF } n, err = r.buf.Read(p) if err == io.EOF { r.buf.Reset(nil) bufioReader32KPool.Put(r.buf) r.buf = nil } return } func (r *bufferedReader) Peek(n int) ([]byte, error) { if r.buf == nil { return nil, io.EOF } return r.buf.Peek(n) } // DetectCompression detects the compression algorithm of the source. func DetectCompression(source []byte) Compression { for compression, m := range map[Compression][]byte{ Gzip: {0x1F, 0x8B, 0x08}, Zstd: {0x28, 0xb5, 0x2f, 0xfd}, } { if len(source) < len(m) { // Len too short continue } if bytes.Equal(m, source[:len(m)]) { return compression } } return Uncompressed } // DecompressStream decompresses the archive and returns a ReaderCloser with the decompressed archive. func DecompressStream(archive io.Reader) (DecompressReadCloser, error) { buf := newBufferedReader(archive) bs, err := buf.Peek(10) if err != nil && err != io.EOF { // Note: we'll ignore any io.EOF error because there are some odd // cases where the layer.tar file will be empty (zero bytes) and // that results in an io.EOF from the Peek() call. So, in those // cases we'll just treat it as a non-compressed stream and // that means just create an empty layer. // See Issue docker/docker#18170 return nil, err } switch compression := DetectCompression(bs); compression { case Uncompressed: return &readCloserWrapper{ Reader: buf, compression: compression, }, nil case Gzip: ctx, cancel := context.WithCancel(context.Background()) gzReader, err := gzipDecompress(ctx, buf) if err != nil { cancel() return nil, err } return &readCloserWrapper{ Reader: gzReader, compression: compression, closer: func() error { cancel() return gzReader.Close() }, }, nil case Zstd: zstdReader, err := zstd.NewReader(buf) if err != nil { return nil, err } return &readCloserWrapper{ Reader: zstdReader, compression: compression, closer: func() error { zstdReader.Close() return nil }, }, nil default: return nil, fmt.Errorf("unsupported compression format %s", (&compression).Extension()) } } // CompressStream compresses the dest with specified compression algorithm. func CompressStream(dest io.Writer, compression Compression) (io.WriteCloser, error) { switch compression { case Uncompressed: return &writeCloserWrapper{dest, nil}, nil case Gzip: return gzip.NewWriter(dest), nil case Zstd: return zstd.NewWriter(dest) default: return nil, fmt.Errorf("unsupported compression format %s", (&compression).Extension()) } } // Extension returns the extension of a file that uses the specified compression algorithm. func (compression *Compression) Extension() string { switch *compression { case Gzip: return "gz" case Zstd: return "zst" } return "" } func gzipDecompress(ctx context.Context, buf io.Reader) (io.ReadCloser, error) { initPigz.Do(func() { if unpigzPath = detectPigz(); unpigzPath != "" { log.L.Debug("using pigz for decompression") } }) if unpigzPath == "" { return gzip.NewReader(buf) } return cmdStream(exec.CommandContext(ctx, unpigzPath, "-d", "-c"), buf) } func cmdStream(cmd *exec.Cmd, in io.Reader) (io.ReadCloser, error) { reader, writer := io.Pipe() cmd.Stdin = in cmd.Stdout = writer var errBuf bytes.Buffer cmd.Stderr = &errBuf if err := cmd.Start(); err != nil { return nil, err } go func() { if err := cmd.Wait(); err != nil { writer.CloseWithError(fmt.Errorf("%s: %s", err, errBuf.String())) } else { writer.Close() } }() return reader, nil } func detectPigz() string { path, err := exec.LookPath("unpigz") if err != nil { log.L.WithError(err).Debug("unpigz not found, falling back to go gzip") return "" } // Check if pigz disabled via CONTAINERD_DISABLE_PIGZ env variable value := os.Getenv(disablePigzEnv) if value == "" { return path } disable, err := strconv.ParseBool(value) if err != nil { log.L.WithError(err).Warnf("could not parse %s: %s", disablePigzEnv, value) return path } if disable { return "" } return path } containerd-1.5.9/archive/compression/compression_test.go000066400000000000000000000120761416535272200236020ustar00rootroot00000000000000/* Copyright The containerd 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 compression import ( "bytes" "compress/gzip" "context" "io" "io/ioutil" "math/rand" "os" "os/exec" "path/filepath" "runtime" "strings" "testing" ) func TestMain(m *testing.M) { // Force initPigz to be called, so tests start with the same initial state gzipDecompress(context.Background(), strings.NewReader("")) os.Exit(m.Run()) } // generateData generates data that composed of 2 random parts // and single zero-filled part within them. // Typically, the compression ratio would be about 67%. func generateData(t *testing.T, size int) []byte { part0 := size / 3 // random part2 := size / 3 // random part1 := size - part0 - part2 // zero-filled part0Data := make([]byte, part0) if _, err := rand.Read(part0Data); err != nil { t.Fatal(err) } part1Data := make([]byte, part1) part2Data := make([]byte, part2) if _, err := rand.Read(part2Data); err != nil { t.Fatal(err) } return append(part0Data, append(part1Data, part2Data...)...) } func testCompressDecompress(t *testing.T, size int, compression Compression) DecompressReadCloser { orig := generateData(t, size) var b bytes.Buffer compressor, err := CompressStream(&b, compression) if err != nil { t.Fatal(err) } if n, err := compressor.Write(orig); err != nil || n != size { t.Fatal(err) } compressor.Close() compressed := b.Bytes() t.Logf("compressed %d bytes to %d bytes (%.2f%%)", len(orig), len(compressed), 100.0*float32(len(compressed))/float32(len(orig))) if compared := bytes.Compare(orig, compressed); (compression == Uncompressed && compared != 0) || (compression != Uncompressed && compared == 0) { t.Fatal("strange compressed data") } decompressor, err := DecompressStream(bytes.NewReader(compressed)) if err != nil { t.Fatal(err) } decompressed, err := ioutil.ReadAll(decompressor) if err != nil { t.Fatal(err) } if !bytes.Equal(orig, decompressed) { t.Fatal("strange decompressed data") } return decompressor } func TestCompressDecompressGzip(t *testing.T) { oldUnpigzPath := unpigzPath unpigzPath = "" defer func() { unpigzPath = oldUnpigzPath }() decompressor := testCompressDecompress(t, 1024*1024, Gzip) wrapper := decompressor.(*readCloserWrapper) _, ok := wrapper.Reader.(*gzip.Reader) if !ok { t.Fatalf("unexpected compressor type: %T", wrapper.Reader) } } func TestCompressDecompressPigz(t *testing.T) { if _, err := exec.LookPath("unpigz"); err != nil { t.Skip("pigz not installed") } decompressor := testCompressDecompress(t, 1024*1024, Gzip) wrapper := decompressor.(*readCloserWrapper) _, ok := wrapper.Reader.(*io.PipeReader) if !ok { t.Fatalf("unexpected compressor type: %T", wrapper.Reader) } } func TestCompressDecompressUncompressed(t *testing.T) { testCompressDecompress(t, 1024*1024, Uncompressed) } func TestDetectPigz(t *testing.T) { // Create fake PATH with unpigz executable, make sure detectPigz can find it tempPath, err := ioutil.TempDir("", "containerd_temp_") if err != nil { t.Fatal(err) } filename := "unpigz" if runtime.GOOS == "windows" { filename = "unpigz.exe" } fullPath := filepath.Join(tempPath, filename) if err := ioutil.WriteFile(fullPath, []byte(""), 0111); err != nil { t.Fatal(err) } defer os.RemoveAll(tempPath) oldPath := os.Getenv("PATH") os.Setenv("PATH", tempPath) defer os.Setenv("PATH", oldPath) if pigzPath := detectPigz(); pigzPath == "" { t.Fatal("failed to detect pigz path") } else if pigzPath != fullPath { t.Fatalf("wrong pigz found: %s != %s", pigzPath, fullPath) } os.Setenv(disablePigzEnv, "1") defer os.Unsetenv(disablePigzEnv) if pigzPath := detectPigz(); pigzPath != "" { t.Fatalf("disable via %s doesn't work", disablePigzEnv) } } func TestCmdStream(t *testing.T) { out, err := cmdStream(exec.Command("sh", "-c", "echo hello; exit 0"), nil) if err != nil { t.Fatal(err) } buf, err := ioutil.ReadAll(out) if err != nil { t.Fatalf("failed to read from stdout: %s", err) } if string(buf) != "hello\n" { t.Fatalf("unexpected command output ('%s' != '%s')", string(buf), "hello\n") } } func TestCmdStreamBad(t *testing.T) { out, err := cmdStream(exec.Command("sh", "-c", "echo hello; echo >&2 bad result; exit 1"), nil) if err != nil { t.Fatalf("failed to start command: %v", err) } if buf, err := ioutil.ReadAll(out); err == nil { t.Fatal("command should have failed") } else if err.Error() != "exit status 1: bad result\n" { t.Fatalf("wrong error: %s", err.Error()) } else if string(buf) != "hello\n" { t.Fatalf("wrong output: %s", string(buf)) } } containerd-1.5.9/archive/issues_test.go000066400000000000000000000036301416535272200202070ustar00rootroot00000000000000/* Copyright The containerd 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 archive import ( "bytes" "context" "io/ioutil" "os" "path/filepath" "strings" "testing" "github.com/containerd/containerd/archive/compression" "github.com/containerd/containerd/pkg/testutil" ) // TestPrefixHeaderReadable tests that files that could be created with the // version of this package that was built with <=go17 are still readable. func TestPrefixHeaderReadable(t *testing.T) { testutil.RequiresRoot(t) // https://gist.github.com/stevvooe/e2a790ad4e97425896206c0816e1a882#file-out-go var testFile = []byte("\x1f\x8b\x08\x08\x44\x21\x68\x59\x00\x03\x74\x2e\x74\x61\x72\x00\x4b\xcb\xcf\x67\xa0\x35\x30\x80\x00\x86\x06\x10\x47\x01\xc1\x37\x40\x00\x54\xb6\xb1\xa1\xa9\x99\x09\x48\x25\x1d\x40\x69\x71\x49\x62\x91\x02\xe5\x76\xa1\x79\x84\x21\x91\xd6\x80\x72\xaf\x8f\x82\x51\x30\x0a\x46\x36\x00\x00\xf0\x1c\x1e\x95\x00\x06\x00\x00") tmpDir, err := ioutil.TempDir("", "prefix-test") if err != nil { t.Fatal(err) } defer os.RemoveAll(tmpDir) r, err := compression.DecompressStream(bytes.NewReader(testFile)) if err != nil { t.Fatal(err) } defer r.Close() _, err = Apply(context.Background(), tmpDir, r) if err != nil { t.Fatal(err) } baseName := "foo" pth := strings.Repeat("a", 100-len(baseName)) + "/" + baseName _, err = os.Lstat(filepath.Join(tmpDir, pth)) if err != nil { t.Fatal(err) } } containerd-1.5.9/archive/tar.go000066400000000000000000000455121416535272200164300ustar00rootroot00000000000000/* Copyright The containerd 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 archive import ( "archive/tar" "context" "io" "os" "path/filepath" "runtime" "strings" "sync" "syscall" "time" "github.com/containerd/containerd/log" "github.com/containerd/continuity/fs" "github.com/pkg/errors" ) var bufPool = &sync.Pool{ New: func() interface{} { buffer := make([]byte, 32*1024) return &buffer }, } var errInvalidArchive = errors.New("invalid archive") // Diff returns a tar stream of the computed filesystem // difference between the provided directories. // // Produces a tar using OCI style file markers for deletions. Deleted // files will be prepended with the prefix ".wh.". This style is // based off AUFS whiteouts. // See https://github.com/opencontainers/image-spec/blob/master/layer.md func Diff(ctx context.Context, a, b string) io.ReadCloser { r, w := io.Pipe() go func() { err := WriteDiff(ctx, w, a, b) if err = w.CloseWithError(err); err != nil { log.G(ctx).WithError(err).Debugf("closing tar pipe failed") } }() return r } // WriteDiff writes a tar stream of the computed difference between the // provided paths. // // Produces a tar using OCI style file markers for deletions. Deleted // files will be prepended with the prefix ".wh.". This style is // based off AUFS whiteouts. // See https://github.com/opencontainers/image-spec/blob/master/layer.md func WriteDiff(ctx context.Context, w io.Writer, a, b string, opts ...WriteDiffOpt) error { var options WriteDiffOptions for _, opt := range opts { if err := opt(&options); err != nil { return errors.Wrap(err, "failed to apply option") } } if options.writeDiffFunc == nil { options.writeDiffFunc = writeDiffNaive } return options.writeDiffFunc(ctx, w, a, b, options) } // writeDiffNaive writes a tar stream of the computed difference between the // provided directories on disk. // // Produces a tar using OCI style file markers for deletions. Deleted // files will be prepended with the prefix ".wh.". This style is // based off AUFS whiteouts. // See https://github.com/opencontainers/image-spec/blob/master/layer.md func writeDiffNaive(ctx context.Context, w io.Writer, a, b string, _ WriteDiffOptions) error { cw := newChangeWriter(w, b) err := fs.Changes(ctx, a, b, cw.HandleChange) if err != nil { return errors.Wrap(err, "failed to create diff tar stream") } return cw.Close() } const ( // whiteoutPrefix prefix means file is a whiteout. If this is followed by a // filename this means that file has been removed from the base layer. // See https://github.com/opencontainers/image-spec/blob/master/layer.md#whiteouts whiteoutPrefix = ".wh." // whiteoutMetaPrefix prefix means whiteout has a special meaning and is not // for removing an actual file. Normally these files are excluded from exported // archives. whiteoutMetaPrefix = whiteoutPrefix + whiteoutPrefix // whiteoutOpaqueDir file means directory has been made opaque - meaning // readdir calls to this directory do not follow to lower layers. whiteoutOpaqueDir = whiteoutMetaPrefix + ".opq" paxSchilyXattr = "SCHILY.xattr." ) // Apply applies a tar stream of an OCI style diff tar. // See https://github.com/opencontainers/image-spec/blob/master/layer.md#applying-changesets func Apply(ctx context.Context, root string, r io.Reader, opts ...ApplyOpt) (int64, error) { root = filepath.Clean(root) var options ApplyOptions for _, opt := range opts { if err := opt(&options); err != nil { return 0, errors.Wrap(err, "failed to apply option") } } if options.Filter == nil { options.Filter = all } if options.applyFunc == nil { options.applyFunc = applyNaive } return options.applyFunc(ctx, root, r, options) } // applyNaive applies a tar stream of an OCI style diff tar to a directory // applying each file as either a whole file or whiteout. // See https://github.com/opencontainers/image-spec/blob/master/layer.md#applying-changesets func applyNaive(ctx context.Context, root string, r io.Reader, options ApplyOptions) (size int64, err error) { var ( dirs []*tar.Header tr = tar.NewReader(r) // Used for handling opaque directory markers which // may occur out of order unpackedPaths = make(map[string]struct{}) convertWhiteout = options.ConvertWhiteout ) if convertWhiteout == nil { // handle whiteouts by removing the target files convertWhiteout = func(hdr *tar.Header, path string) (bool, error) { base := filepath.Base(path) dir := filepath.Dir(path) if base == whiteoutOpaqueDir { _, err := os.Lstat(dir) if err != nil { return false, err } err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error { if err != nil { if os.IsNotExist(err) { err = nil // parent was deleted } return err } if path == dir { return nil } if _, exists := unpackedPaths[path]; !exists { err := os.RemoveAll(path) return err } return nil }) return false, err } if strings.HasPrefix(base, whiteoutPrefix) { originalBase := base[len(whiteoutPrefix):] originalPath := filepath.Join(dir, originalBase) return false, os.RemoveAll(originalPath) } return true, nil } } // Iterate through the files in the archive. for { select { case <-ctx.Done(): return 0, ctx.Err() default: } hdr, err := tr.Next() if err == io.EOF { // end of tar archive break } if err != nil { return 0, err } size += hdr.Size // Normalize name, for safety and for a simple is-root check hdr.Name = filepath.Clean(hdr.Name) accept, err := options.Filter(hdr) if err != nil { return 0, err } if !accept { continue } if skipFile(hdr) { log.G(ctx).Warnf("file %q ignored: archive may not be supported on system", hdr.Name) continue } // Split name and resolve symlinks for root directory. ppath, base := filepath.Split(hdr.Name) ppath, err = fs.RootPath(root, ppath) if err != nil { return 0, errors.Wrap(err, "failed to get root path") } // Join to root before joining to parent path to ensure relative links are // already resolved based on the root before adding to parent. path := filepath.Join(ppath, filepath.Join("/", base)) if path == root { log.G(ctx).Debugf("file %q ignored: resolved to root", hdr.Name) continue } // If file is not directly under root, ensure parent directory // exists or is created. if ppath != root { parentPath := ppath if base == "" { parentPath = filepath.Dir(path) } if err := mkparent(ctx, parentPath, root, options.Parents); err != nil { return 0, err } } // Naive whiteout convert function which handles whiteout files by // removing the target files. if err := validateWhiteout(path); err != nil { return 0, err } writeFile, err := convertWhiteout(hdr, path) if err != nil { return 0, errors.Wrapf(err, "failed to convert whiteout file %q", hdr.Name) } if !writeFile { continue } // If path exits we almost always just want to remove and replace it. // The only exception is when it is a directory *and* the file from // the layer is also a directory. Then we want to merge them (i.e. // just apply the metadata from the layer). if fi, err := os.Lstat(path); err == nil { if !(fi.IsDir() && hdr.Typeflag == tar.TypeDir) { if err := os.RemoveAll(path); err != nil { return 0, err } } } srcData := io.Reader(tr) srcHdr := hdr if err := createTarFile(ctx, path, root, srcHdr, srcData); err != nil { return 0, err } // Directory mtimes must be handled at the end to avoid further // file creation in them to modify the directory mtime if hdr.Typeflag == tar.TypeDir { dirs = append(dirs, hdr) } unpackedPaths[path] = struct{}{} } for _, hdr := range dirs { path, err := fs.RootPath(root, hdr.Name) if err != nil { return 0, err } if err := chtimes(path, boundTime(latestTime(hdr.AccessTime, hdr.ModTime)), boundTime(hdr.ModTime)); err != nil { return 0, err } } return size, nil } func createTarFile(ctx context.Context, path, extractDir string, hdr *tar.Header, reader io.Reader) error { // hdr.Mode is in linux format, which we can use for syscalls, // but for os.Foo() calls we need the mode converted to os.FileMode, // so use hdrInfo.Mode() (they differ for e.g. setuid bits) hdrInfo := hdr.FileInfo() switch hdr.Typeflag { case tar.TypeDir: // Create directory unless it exists as a directory already. // In that case we just want to merge the two if fi, err := os.Lstat(path); !(err == nil && fi.IsDir()) { if err := mkdir(path, hdrInfo.Mode()); err != nil { return err } } case tar.TypeReg, tar.TypeRegA: file, err := openFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, hdrInfo.Mode()) if err != nil { return err } _, err = copyBuffered(ctx, file, reader) if err1 := file.Close(); err == nil { err = err1 } if err != nil { return err } case tar.TypeBlock, tar.TypeChar: // Handle this is an OS-specific way if err := handleTarTypeBlockCharFifo(hdr, path); err != nil { return err } case tar.TypeFifo: // Handle this is an OS-specific way if err := handleTarTypeBlockCharFifo(hdr, path); err != nil { return err } case tar.TypeLink: targetPath, err := hardlinkRootPath(extractDir, hdr.Linkname) if err != nil { return err } if err := os.Link(targetPath, path); err != nil { return err } case tar.TypeSymlink: if err := os.Symlink(hdr.Linkname, path); err != nil { return err } case tar.TypeXGlobalHeader: log.G(ctx).Debug("PAX Global Extended Headers found and ignored") return nil default: return errors.Errorf("unhandled tar header type %d\n", hdr.Typeflag) } // Lchown is not supported on Windows. if runtime.GOOS != "windows" { if err := os.Lchown(path, hdr.Uid, hdr.Gid); err != nil { return err } } for key, value := range hdr.PAXRecords { if strings.HasPrefix(key, paxSchilyXattr) { key = key[len(paxSchilyXattr):] if err := setxattr(path, key, value); err != nil { if errors.Is(err, syscall.ENOTSUP) { log.G(ctx).WithError(err).Warnf("ignored xattr %s in archive", key) continue } return err } } } // call lchmod after lchown since lchown can modify the file mode if err := lchmod(path, hdrInfo.Mode()); err != nil { return err } return chtimes(path, boundTime(latestTime(hdr.AccessTime, hdr.ModTime)), boundTime(hdr.ModTime)) } func mkparent(ctx context.Context, path, root string, parents []string) error { if dir, err := os.Lstat(path); err == nil { if dir.IsDir() { return nil } return &os.PathError{ Op: "mkparent", Path: path, Err: syscall.ENOTDIR, } } else if !os.IsNotExist(err) { return err } i := len(path) for i > len(root) && !os.IsPathSeparator(path[i-1]) { i-- } if i > len(root)+1 { if err := mkparent(ctx, path[:i-1], root, parents); err != nil { return err } } if err := mkdir(path, 0755); err != nil { // Check that still doesn't exist dir, err1 := os.Lstat(path) if err1 == nil && dir.IsDir() { return nil } return err } for _, p := range parents { ppath, err := fs.RootPath(p, path[len(root):]) if err != nil { return err } dir, err := os.Lstat(ppath) if err == nil { if !dir.IsDir() { // Replaced, do not copy attributes break } if err := copyDirInfo(dir, path); err != nil { return err } return copyUpXAttrs(path, ppath) } else if !os.IsNotExist(err) { return err } } log.G(ctx).Debugf("parent directory %q not found: default permissions(0755) used", path) return nil } type changeWriter struct { tw *tar.Writer source string whiteoutT time.Time inodeSrc map[uint64]string inodeRefs map[uint64][]string addedDirs map[string]struct{} } func newChangeWriter(w io.Writer, source string) *changeWriter { return &changeWriter{ tw: tar.NewWriter(w), source: source, whiteoutT: time.Now(), inodeSrc: map[uint64]string{}, inodeRefs: map[uint64][]string{}, addedDirs: map[string]struct{}{}, } } func (cw *changeWriter) HandleChange(k fs.ChangeKind, p string, f os.FileInfo, err error) error { if err != nil { return err } if k == fs.ChangeKindDelete { whiteOutDir := filepath.Dir(p) whiteOutBase := filepath.Base(p) whiteOut := filepath.Join(whiteOutDir, whiteoutPrefix+whiteOutBase) hdr := &tar.Header{ Typeflag: tar.TypeReg, Name: whiteOut[1:], Size: 0, ModTime: cw.whiteoutT, AccessTime: cw.whiteoutT, ChangeTime: cw.whiteoutT, } if err := cw.includeParents(hdr); err != nil { return err } if err := cw.tw.WriteHeader(hdr); err != nil { return errors.Wrap(err, "failed to write whiteout header") } } else { var ( link string err error source = filepath.Join(cw.source, p) ) switch { case f.Mode()&os.ModeSocket != 0: return nil // ignore sockets case f.Mode()&os.ModeSymlink != 0: if link, err = os.Readlink(source); err != nil { return err } } hdr, err := tar.FileInfoHeader(f, link) if err != nil { return err } hdr.Mode = int64(chmodTarEntry(os.FileMode(hdr.Mode))) // truncate timestamp for compatibility. without PAX stdlib rounds timestamps instead hdr.Format = tar.FormatPAX hdr.ModTime = hdr.ModTime.Truncate(time.Second) hdr.AccessTime = time.Time{} hdr.ChangeTime = time.Time{} name := p if strings.HasPrefix(name, string(filepath.Separator)) { name, err = filepath.Rel(string(filepath.Separator), name) if err != nil { return errors.Wrap(err, "failed to make path relative") } } name, err = tarName(name) if err != nil { return errors.Wrap(err, "cannot canonicalize path") } // suffix with '/' for directories if f.IsDir() && !strings.HasSuffix(name, "/") { name += "/" } hdr.Name = name if err := setHeaderForSpecialDevice(hdr, name, f); err != nil { return errors.Wrap(err, "failed to set device headers") } // additionalLinks stores file names which must be linked to // this file when this file is added var additionalLinks []string inode, isHardlink := fs.GetLinkInfo(f) if isHardlink { // If the inode has a source, always link to it if source, ok := cw.inodeSrc[inode]; ok { hdr.Typeflag = tar.TypeLink hdr.Linkname = source hdr.Size = 0 } else { if k == fs.ChangeKindUnmodified { cw.inodeRefs[inode] = append(cw.inodeRefs[inode], name) return nil } cw.inodeSrc[inode] = name additionalLinks = cw.inodeRefs[inode] delete(cw.inodeRefs, inode) } } else if k == fs.ChangeKindUnmodified { // Nothing to write to diff return nil } if capability, err := getxattr(source, "security.capability"); err != nil { return errors.Wrap(err, "failed to get capabilities xattr") } else if capability != nil { if hdr.PAXRecords == nil { hdr.PAXRecords = map[string]string{} } hdr.PAXRecords[paxSchilyXattr+"security.capability"] = string(capability) } if err := cw.includeParents(hdr); err != nil { return err } if err := cw.tw.WriteHeader(hdr); err != nil { return errors.Wrap(err, "failed to write file header") } if hdr.Typeflag == tar.TypeReg && hdr.Size > 0 { file, err := open(source) if err != nil { return errors.Wrapf(err, "failed to open path: %v", source) } defer file.Close() n, err := copyBuffered(context.TODO(), cw.tw, file) if err != nil { return errors.Wrap(err, "failed to copy") } if n != hdr.Size { return errors.New("short write copying file") } } if additionalLinks != nil { source = hdr.Name for _, extra := range additionalLinks { hdr.Name = extra hdr.Typeflag = tar.TypeLink hdr.Linkname = source hdr.Size = 0 if err := cw.includeParents(hdr); err != nil { return err } if err := cw.tw.WriteHeader(hdr); err != nil { return errors.Wrap(err, "failed to write file header") } } } } return nil } func (cw *changeWriter) Close() error { if err := cw.tw.Close(); err != nil { return errors.Wrap(err, "failed to close tar writer") } return nil } func (cw *changeWriter) includeParents(hdr *tar.Header) error { if cw.addedDirs == nil { return nil } name := strings.TrimRight(hdr.Name, "/") fname := filepath.Join(cw.source, name) parent := filepath.Dir(name) pname := filepath.Join(cw.source, parent) // Do not include root directory as parent if fname != cw.source && pname != cw.source { _, ok := cw.addedDirs[parent] if !ok { cw.addedDirs[parent] = struct{}{} fi, err := os.Stat(pname) if err != nil { return err } if err := cw.HandleChange(fs.ChangeKindModify, parent, fi, nil); err != nil { return err } } } if hdr.Typeflag == tar.TypeDir { cw.addedDirs[name] = struct{}{} } return nil } func copyBuffered(ctx context.Context, dst io.Writer, src io.Reader) (written int64, err error) { buf := bufPool.Get().(*[]byte) defer bufPool.Put(buf) for { select { case <-ctx.Done(): err = ctx.Err() return default: } nr, er := src.Read(*buf) if nr > 0 { nw, ew := dst.Write((*buf)[0:nr]) if nw > 0 { written += int64(nw) } if ew != nil { err = ew break } if nr != nw { err = io.ErrShortWrite break } } if er != nil { if er != io.EOF { err = er } break } } return written, err } // hardlinkRootPath returns target linkname, evaluating and bounding any // symlink to the parent directory. // // NOTE: Allow hardlink to the softlink, not the real one. For example, // // touch /tmp/zzz // ln -s /tmp/zzz /tmp/xxx // ln /tmp/xxx /tmp/yyy // // /tmp/yyy should be softlink which be same of /tmp/xxx, not /tmp/zzz. func hardlinkRootPath(root, linkname string) (string, error) { ppath, base := filepath.Split(linkname) ppath, err := fs.RootPath(root, ppath) if err != nil { return "", err } targetPath := filepath.Join(ppath, base) if !strings.HasPrefix(targetPath, root) { targetPath = root } return targetPath, nil } func validateWhiteout(path string) error { base := filepath.Base(path) dir := filepath.Dir(path) if base == whiteoutOpaqueDir { return nil } if strings.HasPrefix(base, whiteoutPrefix) { originalBase := base[len(whiteoutPrefix):] originalPath := filepath.Join(dir, originalBase) // Ensure originalPath is under dir if dir[len(dir)-1] != filepath.Separator { dir += string(filepath.Separator) } if !strings.HasPrefix(originalPath, dir) { return errors.Wrapf(errInvalidArchive, "invalid whiteout name: %v", base) } } return nil } containerd-1.5.9/archive/tar_freebsd.go000066400000000000000000000025601416535272200201160ustar00rootroot00000000000000// +build freebsd /* Copyright The containerd 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 archive import ( "os" "golang.org/x/sys/unix" ) // mknod wraps unix.Mknod. FreeBSD's unix.Mknod signature is different from // other Unix and Unix-like operating systems. func mknod(path string, mode uint32, dev uint64) error { return unix.Mknod(path, mode, dev) } // lsetxattrCreate wraps unix.Lsetxattr with FreeBSD-specific flags and errors func lsetxattrCreate(link string, attr string, data []byte) error { err := unix.Lsetxattr(link, attr, data, 0) if err == unix.ENOTSUP || err == unix.EEXIST { return nil } return err } func lchmod(path string, mode os.FileMode) error { err := unix.Fchmodat(unix.AT_FDCWD, path, uint32(mode), unix.AT_SYMLINK_NOFOLLOW) if err != nil { err = &os.PathError{Op: "lchmod", Path: path, Err: err} } return err } containerd-1.5.9/archive/tar_linux_test.go000066400000000000000000000107011416535272200206760ustar00rootroot00000000000000// +build linux /* Copyright The containerd 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 archive import ( "bytes" "context" "fmt" "io" "io/ioutil" "os" "strings" "testing" "github.com/containerd/containerd/log/logtest" "github.com/containerd/containerd/mount" "github.com/containerd/containerd/pkg/testutil" "github.com/containerd/containerd/snapshots/overlay/overlayutils" "github.com/containerd/continuity/fs" "github.com/containerd/continuity/fs/fstest" "github.com/pkg/errors" ) func TestOverlayApply(t *testing.T) { testutil.RequiresRoot(t) base, err := ioutil.TempDir("", "test-ovl-diff-apply-") if err != nil { t.Fatalf("unable to create temp dir: %+v", err) } defer os.RemoveAll(base) if err := overlayutils.Supported(base); err != nil { t.Skipf("skipping because overlay is not supported %v", err) } fstest.FSSuite(t, overlayDiffApplier{ tmp: base, diff: WriteDiff, t: t, }) } func TestOverlayApplyNoParents(t *testing.T) { testutil.RequiresRoot(t) base, err := ioutil.TempDir("", "test-ovl-diff-apply-") if err != nil { t.Fatalf("unable to create temp dir: %+v", err) } defer os.RemoveAll(base) if err := overlayutils.Supported(base); err != nil { t.Skipf("skipping because overlay is not supported %v", err) } fstest.FSSuite(t, overlayDiffApplier{ tmp: base, diff: func(ctx context.Context, w io.Writer, a, b string, _ ...WriteDiffOpt) error { cw := newChangeWriter(w, b) cw.addedDirs = nil err := fs.Changes(ctx, a, b, cw.HandleChange) if err != nil { return errors.Wrap(err, "failed to create diff tar stream") } return cw.Close() }, t: t, }) } type overlayDiffApplier struct { tmp string diff func(context.Context, io.Writer, string, string, ...WriteDiffOpt) error t *testing.T } type overlayContext struct { merged string lowers []string mounted bool } type contextKey struct{} func (d overlayDiffApplier) TestContext(ctx context.Context) (context.Context, func(), error) { merged, err := ioutil.TempDir(d.tmp, "merged") if err != nil { return ctx, nil, errors.Wrap(err, "failed to make merged dir") } oc := &overlayContext{ merged: merged, } ctx = logtest.WithT(ctx, d.t) return context.WithValue(ctx, contextKey{}, oc), func() { if oc.mounted { mount.Unmount(oc.merged, 0) } }, nil } func (d overlayDiffApplier) Apply(ctx context.Context, a fstest.Applier) (string, func(), error) { oc := ctx.Value(contextKey{}).(*overlayContext) applyCopy, err := ioutil.TempDir(d.tmp, "apply-copy-") if err != nil { return "", nil, errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(applyCopy) base := oc.merged if len(oc.lowers) == 1 { base = oc.lowers[0] } if err = fs.CopyDir(applyCopy, base); err != nil { return "", nil, errors.Wrap(err, "failed to copy base") } if err := a.Apply(applyCopy); err != nil { return "", nil, errors.Wrap(err, "failed to apply changes to copy of base") } buf := bytes.NewBuffer(nil) if err := d.diff(ctx, buf, base, applyCopy); err != nil { return "", nil, errors.Wrap(err, "failed to create diff") } if oc.mounted { if err := mount.Unmount(oc.merged, 0); err != nil { return "", nil, errors.Wrap(err, "failed to unmount") } oc.mounted = false } next, err := ioutil.TempDir(d.tmp, "lower-") if err != nil { return "", nil, errors.Wrap(err, "failed to create temp dir") } if _, err = Apply(ctx, next, buf, WithConvertWhiteout(OverlayConvertWhiteout), WithParents(oc.lowers)); err != nil { return "", nil, errors.Wrap(err, "failed to apply tar stream") } oc.lowers = append([]string{next}, oc.lowers...) if len(oc.lowers) == 1 { return oc.lowers[0], nil, nil } m := mount.Mount{ Type: "overlay", Source: "overlay", Options: []string{ fmt.Sprintf("lowerdir=%s", strings.Join(oc.lowers, ":")), }, } if err := m.Mount(oc.merged); err != nil { return "", nil, errors.Wrapf(err, "failed to mount: %v", m) } oc.mounted = true return oc.merged, nil, nil } containerd-1.5.9/archive/tar_mostunix.go000066400000000000000000000027351416535272200203760ustar00rootroot00000000000000// +build !windows,!freebsd /* Copyright The containerd 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 archive import ( "os" "golang.org/x/sys/unix" ) // mknod wraps Unix.Mknod and casts dev to int func mknod(path string, mode uint32, dev uint64) error { return unix.Mknod(path, mode, int(dev)) } // lsetxattrCreate wraps unix.Lsetxattr, passes the unix.XATTR_CREATE flag on // supported operating systems,and ignores appropriate errors func lsetxattrCreate(link string, attr string, data []byte) error { err := unix.Lsetxattr(link, attr, data, unix.XATTR_CREATE) if err == unix.ENOTSUP || err == unix.ENODATA || err == unix.EEXIST { return nil } return err } // lchmod checks for symlink and changes the mode if not a symlink func lchmod(path string, mode os.FileMode) error { fi, err := os.Lstat(path) if err != nil { return err } if fi.Mode()&os.ModeSymlink == 0 { if err := os.Chmod(path, mode); err != nil { return err } } return nil } containerd-1.5.9/archive/tar_opts.go000066400000000000000000000053251416535272200174730ustar00rootroot00000000000000/* Copyright The containerd 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 archive import ( "archive/tar" "context" "io" ) // ApplyOptions provides additional options for an Apply operation type ApplyOptions struct { Filter Filter // Filter tar headers ConvertWhiteout ConvertWhiteout // Convert whiteout files Parents []string // Parent directories to handle inherited attributes without CoW applyFunc func(context.Context, string, io.Reader, ApplyOptions) (int64, error) } // ApplyOpt allows setting mutable archive apply properties on creation type ApplyOpt func(options *ApplyOptions) error // Filter specific files from the archive type Filter func(*tar.Header) (bool, error) // ConvertWhiteout converts whiteout files from the archive type ConvertWhiteout func(*tar.Header, string) (bool, error) // all allows all files func all(_ *tar.Header) (bool, error) { return true, nil } // WithFilter uses the filter to select which files are to be extracted. func WithFilter(f Filter) ApplyOpt { return func(options *ApplyOptions) error { options.Filter = f return nil } } // WithConvertWhiteout uses the convert function to convert the whiteout files. func WithConvertWhiteout(c ConvertWhiteout) ApplyOpt { return func(options *ApplyOptions) error { options.ConvertWhiteout = c return nil } } // WithParents provides parent directories for resolving inherited attributes // directory from the filesystem. // Inherited attributes are searched from first to last, making the first // element in the list the most immediate parent directory. // NOTE: When applying to a filesystem which supports CoW, file attributes // should be inherited by the filesystem. func WithParents(p []string) ApplyOpt { return func(options *ApplyOptions) error { options.Parents = p return nil } } // WriteDiffOptions provides additional options for a WriteDiff operation type WriteDiffOptions struct { ParentLayers []string // Windows needs the full list of parent layers writeDiffFunc func(context.Context, io.Writer, string, string, WriteDiffOptions) error } // WriteDiffOpt allows setting mutable archive write properties on creation type WriteDiffOpt func(options *WriteDiffOptions) error containerd-1.5.9/archive/tar_opts_linux.go000066400000000000000000000032651416535272200207130ustar00rootroot00000000000000// +build linux /* Copyright The containerd 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 archive import ( "archive/tar" "os" "path/filepath" "strings" "golang.org/x/sys/unix" ) // AufsConvertWhiteout converts whiteout files for aufs. func AufsConvertWhiteout(_ *tar.Header, _ string) (bool, error) { return true, nil } // OverlayConvertWhiteout converts whiteout files for overlay. func OverlayConvertWhiteout(hdr *tar.Header, path string) (bool, error) { base := filepath.Base(path) dir := filepath.Dir(path) // if a directory is marked as opaque, we need to translate that to overlay if base == whiteoutOpaqueDir { // don't write the file itself return false, unix.Setxattr(dir, "trusted.overlay.opaque", []byte{'y'}, 0) } // if a file was deleted and we are using overlay, we need to create a character device if strings.HasPrefix(base, whiteoutPrefix) { originalBase := base[len(whiteoutPrefix):] originalPath := filepath.Join(dir, originalBase) if err := unix.Mknod(originalPath, unix.S_IFCHR, 0); err != nil { return false, err } // don't write the file itself return false, os.Chown(originalPath, hdr.Uid, hdr.Gid) } return true, nil } containerd-1.5.9/archive/tar_opts_windows.go000066400000000000000000000051011416535272200212350ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 archive import ( "context" "io" "github.com/Microsoft/hcsshim/pkg/ociwclayer" ) // applyWindowsLayer applies a tar stream of an OCI style diff tar of a Windows layer // See https://github.com/opencontainers/image-spec/blob/master/layer.md#applying-changesets func applyWindowsLayer(ctx context.Context, root string, r io.Reader, options ApplyOptions) (size int64, err error) { return ociwclayer.ImportLayerFromTar(ctx, r, root, options.Parents) } // AsWindowsContainerLayer indicates that the tar stream to apply is that of // a Windows Container Layer. The caller must be holding SeBackupPrivilege and // SeRestorePrivilege. func AsWindowsContainerLayer() ApplyOpt { return func(options *ApplyOptions) error { options.applyFunc = applyWindowsLayer return nil } } // writeDiffWindowsLayers writes a tar stream of the computed difference between the // provided Windows layers // // Produces a tar using OCI style file markers for deletions. Deleted // files will be prepended with the prefix ".wh.". This style is // based off AUFS whiteouts. // See https://github.com/opencontainers/image-spec/blob/master/layer.md func writeDiffWindowsLayers(ctx context.Context, w io.Writer, _, layer string, options WriteDiffOptions) error { return ociwclayer.ExportLayerToTar(ctx, w, layer, options.ParentLayers) } // AsWindowsContainerLayerPair indicates that the paths to diff are a pair of // Windows Container Layers. The caller must be holding SeBackupPrivilege. func AsWindowsContainerLayerPair() WriteDiffOpt { return func(options *WriteDiffOptions) error { options.writeDiffFunc = writeDiffWindowsLayers return nil } } // WithParentLayers provides the Windows Container Layers that are the parents // of the target (right-hand, "upper") layer, if any. The source (left-hand, "lower") // layer passed to WriteDiff should be "" in this case. func WithParentLayers(p []string) WriteDiffOpt { return func(options *WriteDiffOptions) error { options.ParentLayers = p return nil } } containerd-1.5.9/archive/tar_test.go000066400000000000000000001101331416535272200174570ustar00rootroot00000000000000// +build !windows,!darwin /* Copyright The containerd 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 archive import ( "archive/tar" "bytes" "context" "fmt" "io" "io/ioutil" "os" "os/exec" "path/filepath" "testing" "time" _ "crypto/sha256" "github.com/containerd/containerd/archive/tartest" "github.com/containerd/containerd/pkg/testutil" "github.com/containerd/continuity/fs" "github.com/containerd/continuity/fs/fstest" "github.com/pkg/errors" ) const tarCmd = "tar" // baseApplier creates a basic filesystem layout // with multiple types of files for basic tests. var baseApplier = fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/hosts", []byte("127.0.0.1 localhost"), 0644), fstest.Link("/etc/hosts", "/etc/hosts.allow"), fstest.CreateDir("/usr/local/lib", 0755), fstest.CreateFile("/usr/local/lib/libnothing.so", []byte{0x00, 0x00}, 0755), fstest.Symlink("libnothing.so", "/usr/local/lib/libnothing.so.2"), fstest.CreateDir("/home", 0755), fstest.CreateDir("/home/derek", 0700), ) func TestUnpack(t *testing.T) { requireTar(t) if err := testApply(baseApplier); err != nil { t.Fatalf("Test apply failed: %+v", err) } } func TestBaseDiff(t *testing.T) { requireTar(t) if err := testBaseDiff(baseApplier); err != nil { t.Fatalf("Test base diff failed: %+v", err) } } func TestRelativeSymlinks(t *testing.T) { breakoutLinks := []fstest.Applier{ fstest.Apply( baseApplier, fstest.Symlink("../other", "/home/derek/other"), fstest.Symlink("../../etc", "/home/derek/etc"), fstest.Symlink("up/../../other", "/home/derek/updown"), ), fstest.Apply( baseApplier, fstest.Symlink("../../../breakout", "/home/derek/breakout"), ), fstest.Apply( baseApplier, fstest.Symlink("../../breakout", "/breakout"), ), fstest.Apply( baseApplier, fstest.Symlink("etc/../../upandout", "/breakout"), ), fstest.Apply( baseApplier, fstest.Symlink("derek/../../../downandout", "/home/breakout"), ), fstest.Apply( baseApplier, fstest.Symlink("/etc", "localetc"), ), } for _, bo := range breakoutLinks { if err := testDiffApply(bo); err != nil { t.Fatalf("Test apply failed: %+v", err) } } } func TestSymlinks(t *testing.T) { links := [][2]fstest.Applier{ { fstest.Apply( fstest.CreateDir("/bin/", 0755), fstest.CreateFile("/bin/superbinary", []byte{0x00, 0x00}, 0755), fstest.Symlink("../bin/superbinary", "/bin/other1"), ), fstest.Apply( fstest.Remove("/bin/other1"), fstest.Symlink("/bin/superbinary", "/bin/other1"), fstest.Symlink("../bin/superbinary", "/bin/other2"), fstest.Symlink("superbinary", "/bin/other3"), ), }, { fstest.Apply( fstest.CreateDir("/bin/", 0755), fstest.CreateDir("/sbin/", 0755), fstest.CreateFile("/sbin/superbinary", []byte{0x00, 0x00}, 0755), fstest.Symlink("/sbin/superbinary", "/bin/superbinary"), fstest.Symlink("../bin/superbinary", "/bin/other1"), ), fstest.Apply( fstest.Remove("/bin/other1"), fstest.Symlink("/bin/superbinary", "/bin/other1"), fstest.Symlink("superbinary", "/bin/other2"), ), }, { fstest.Apply( fstest.CreateDir("/bin/", 0755), fstest.CreateDir("/sbin/", 0755), fstest.CreateFile("/sbin/superbinary", []byte{0x00, 0x00}, 0755), fstest.Symlink("../sbin/superbinary", "/bin/superbinary"), fstest.Symlink("../bin/superbinary", "/bin/other1"), ), fstest.Apply( fstest.Remove("/bin/other1"), fstest.Symlink("/bin/superbinary", "/bin/other1"), ), }, { fstest.Apply( fstest.CreateDir("/bin/", 0755), fstest.CreateFile("/bin/actualbinary", []byte{0x00, 0x00}, 0755), fstest.Symlink("actualbinary", "/bin/superbinary"), fstest.Symlink("../bin/superbinary", "/bin/other1"), fstest.Symlink("superbinary", "/bin/other2"), ), fstest.Apply( fstest.Remove("/bin/other1"), fstest.Remove("/bin/other2"), fstest.Symlink("/bin/superbinary", "/bin/other1"), fstest.Symlink("superbinary", "/bin/other2"), ), }, { fstest.Apply( fstest.CreateDir("/bin/", 0755), fstest.CreateFile("/bin/actualbinary", []byte{0x00, 0x00}, 0755), fstest.Symlink("actualbinary", "/bin/myapp"), ), fstest.Apply( fstest.Remove("/bin/myapp"), fstest.CreateDir("/bin/myapp", 0755), ), }, } for i, l := range links { if err := testDiffApply(l[0], l[1]); err != nil { t.Fatalf("Test[%d] apply failed: %+v", i+1, err) } } } func TestTarWithXattr(t *testing.T) { testutil.RequiresRoot(t) fileXattrExist := func(f1, xattrKey, xattrValue string) func(string) error { return func(root string) error { values, err := getxattr(filepath.Join(root, f1), xattrKey) if err != nil { return err } if xattrValue != string(values) { return fmt.Errorf("file xattrs expect to be %s, actually get %s", xattrValue, values) } return nil } } tests := []struct { name string key string value string err error }{ { name: "WithXattrsUser", key: "user.key", value: "value", }, { // security related xattrs need root permission to test name: "WithXattrSelinux", key: "security.selinux", value: "unconfined_u:object_r:default_t:s0\x00", }, } for _, at := range tests { tc := tartest.TarContext{}.WithUIDGID(os.Getuid(), os.Getgid()).WithModTime(time.Now().UTC()).WithXattrs(map[string]string{ at.key: at.value, }) w := tartest.TarAll(tc.File("/file", []byte{}, 0755)) validator := fileXattrExist("file", at.key, at.value) t.Run(at.name, makeWriterToTarTest(w, nil, validator, at.err)) } } func TestBreakouts(t *testing.T) { tc := tartest.TarContext{}.WithUIDGID(os.Getuid(), os.Getgid()).WithModTime(time.Now().UTC()) expected := "unbroken" unbrokenCheck := func(root string) error { b, err := ioutil.ReadFile(filepath.Join(root, "etc", "unbroken")) if err != nil { return errors.Wrap(err, "failed to read unbroken") } if string(b) != expected { return errors.Errorf("/etc/unbroken: unexpected value %s, expected %s", b, expected) } return nil } errFileDiff := errors.New("files differ") td, err := ioutil.TempDir("", "test-breakouts-") if err != nil { t.Fatal(err) } defer os.RemoveAll(td) isSymlinkFile := func(f string) func(string) error { return func(root string) error { fi, err := os.Lstat(filepath.Join(root, f)) if err != nil { return err } if got := fi.Mode() & os.ModeSymlink; got != os.ModeSymlink { return errors.Errorf("%s should be symlink", fi.Name()) } return nil } } sameSymlinkFile := func(f1, f2 string) func(string) error { checkF1, checkF2 := isSymlinkFile(f1), isSymlinkFile(f2) return func(root string) error { if err := checkF1(root); err != nil { return err } if err := checkF2(root); err != nil { return err } t1, err := os.Readlink(filepath.Join(root, f1)) if err != nil { return err } t2, err := os.Readlink(filepath.Join(root, f2)) if err != nil { return err } if t1 != t2 { return errors.Wrapf(errFileDiff, "%#v and %#v", t1, t2) } return nil } } sameFile := func(f1, f2 string) func(string) error { return func(root string) error { p1, err := fs.RootPath(root, f1) if err != nil { return err } p2, err := fs.RootPath(root, f2) if err != nil { return err } s1, err := os.Stat(p1) if err != nil { return err } s2, err := os.Stat(p2) if err != nil { return err } if !os.SameFile(s1, s2) { return errors.Wrapf(errFileDiff, "%#v and %#v", s1, s2) } return nil } } notSameFile := func(f1, f2 string) func(string) error { same := sameFile(f1, f2) return func(root string) error { err := same(root) if err == nil { return errors.New("files are the same, expected diff") } if !errors.Is(err, errFileDiff) { return err } return nil } } fileValue := func(f1 string, content []byte) func(string) error { return func(root string) error { b, err := ioutil.ReadFile(filepath.Join(root, f1)) if err != nil { return err } if !bytes.Equal(b, content) { return errors.Errorf("content differs: expected %v, got %v", content, b) } return nil } } fileNotExists := func(f1 string) func(string) error { return func(root string) error { _, err := os.Lstat(filepath.Join(root, f1)) if err == nil { return errors.New("file exists") } else if !os.IsNotExist(err) { return err } return nil } } all := func(funcs ...func(string) error) func(string) error { return func(root string) error { for _, f := range funcs { if err := f(root); err != nil { return err } } return nil } } breakouts := []struct { name string w tartest.WriterToTar apply fstest.Applier validator func(string) error err error }{ { name: "SymlinkAbsolute", w: tartest.TarAll( tc.Dir("etc", 0755), tc.Symlink("/etc", "localetc"), tc.File("/localetc/unbroken", []byte(expected), 0644), ), validator: unbrokenCheck, }, { name: "SymlinkUpAndOut", w: tartest.TarAll( tc.Dir("etc", 0755), tc.Dir("dummy", 0755), tc.Symlink("/dummy/../etc", "localetc"), tc.File("/localetc/unbroken", []byte(expected), 0644), ), validator: unbrokenCheck, }, { name: "SymlinkMultipleAbsolute", w: tartest.TarAll( tc.Dir("etc", 0755), tc.Dir("dummy", 0755), tc.Symlink("/etc", "/dummy/etc"), tc.Symlink("/dummy/etc", "localetc"), tc.File("/dummy/etc/unbroken", []byte(expected), 0644), ), validator: unbrokenCheck, }, { name: "SymlinkMultipleRelative", w: tartest.TarAll( tc.Dir("etc", 0755), tc.Dir("dummy", 0755), tc.Symlink("/etc", "/dummy/etc"), tc.Symlink("./dummy/etc", "localetc"), tc.File("/dummy/etc/unbroken", []byte(expected), 0644), ), validator: unbrokenCheck, }, { name: "SymlinkEmptyFile", w: tartest.TarAll( tc.Dir("etc", 0755), tc.File("etc/emptied", []byte("notempty"), 0644), tc.Symlink("/etc", "localetc"), tc.File("/localetc/emptied", []byte{}, 0644), ), validator: func(root string) error { b, err := ioutil.ReadFile(filepath.Join(root, "etc", "emptied")) if err != nil { return errors.Wrap(err, "failed to read unbroken") } if len(b) > 0 { return errors.Errorf("/etc/emptied: non-empty") } return nil }, }, { name: "HardlinkRelative", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Dir("breakouts", 0755), tc.Symlink("../../etc", "breakouts/d1"), tc.Link("/breakouts/d1/passwd", "breakouts/mypasswd"), ), validator: sameFile("/breakouts/mypasswd", "/etc/passwd"), }, { name: "HardlinkDownAndOut", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Dir("breakouts", 0755), tc.Dir("downandout", 0755), tc.Symlink("../downandout/../../etc", "breakouts/d1"), tc.Link("/breakouts/d1/passwd", "breakouts/mypasswd"), ), validator: sameFile("/breakouts/mypasswd", "/etc/passwd"), }, { name: "HardlinkAbsolute", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("/etc", "localetc"), tc.Link("/localetc/passwd", "localpasswd"), ), validator: sameFile("localpasswd", "/etc/passwd"), }, { name: "HardlinkRelativeLong", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("../../../../../../../etc", "localetc"), tc.Link("/localetc/passwd", "localpasswd"), ), validator: sameFile("localpasswd", "/etc/passwd"), }, { name: "HardlinkRelativeUpAndOut", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("upandout/../../../etc", "localetc"), tc.Link("/localetc/passwd", "localpasswd"), ), validator: sameFile("localpasswd", "/etc/passwd"), }, { name: "HardlinkDirectRelative", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Link("../../../../../etc/passwd", "localpasswd"), ), validator: sameFile("localpasswd", "/etc/passwd"), }, { name: "HardlinkDirectAbsolute", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Link("/etc/passwd", "localpasswd"), ), validator: sameFile("localpasswd", "/etc/passwd"), }, { name: "HardlinkSymlinkBeforeCreateTarget", w: tartest.TarAll( tc.Dir("etc", 0770), tc.Symlink("/etc/passwd", "localpasswd"), tc.Link("localpasswd", "localpasswd-dup"), tc.File("/etc/passwd", []byte("after"), 0644), ), validator: sameFile("localpasswd-dup", "/etc/passwd"), }, { name: "HardlinkSymlinkRelative", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("../../../../../etc/passwd", "passwdlink"), tc.Link("/passwdlink", "localpasswd"), ), validator: all( sameSymlinkFile("/localpasswd", "/passwdlink"), sameFile("/localpasswd", "/etc/passwd"), ), }, { name: "HardlinkSymlinkAbsolute", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("/etc/passwd", "passwdlink"), tc.Link("/passwdlink", "localpasswd"), ), validator: all( sameSymlinkFile("/localpasswd", "/passwdlink"), sameFile("/localpasswd", "/etc/passwd"), ), }, { name: "SymlinkParentDirectory", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("/etc/", ".."), tc.Link("/etc/passwd", "localpasswd"), ), validator: sameFile("/localpasswd", "/etc/passwd"), }, { name: "SymlinkEmptyFilename", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("/etc/", ""), tc.Link("/etc/passwd", "localpasswd"), ), validator: sameFile("/localpasswd", "/etc/passwd"), }, { name: "SymlinkParentRelative", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Symlink("/etc/", "localetc/sub/.."), tc.Link("/etc/passwd", "/localetc/localpasswd"), ), validator: sameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "SymlinkSlashEnded", w: tartest.TarAll( tc.Dir("etc", 0770), tc.File("/etc/passwd", []byte("inside"), 0644), tc.Dir("localetc/", 0770), tc.Link("/etc/passwd", "/localetc/localpasswd"), ), validator: sameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "SymlinkOverrideDirectory", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), fstest.CreateDir("/localetc/", 0755), ), w: tartest.TarAll( tc.Symlink("/etc", "localetc"), tc.Link("/etc/passwd", "/localetc/localpasswd"), ), validator: sameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "SymlinkOverrideDirectoryRelative", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), fstest.CreateDir("/localetc/", 0755), ), w: tartest.TarAll( tc.Symlink("../../etc", "localetc"), tc.Link("/etc/passwd", "/localetc/localpasswd"), ), validator: sameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "DirectoryOverrideSymlink", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), fstest.Symlink("/etc", "localetc"), ), w: tartest.TarAll( tc.Dir("/localetc/", 0755), tc.Link("/etc/passwd", "/localetc/localpasswd"), ), validator: sameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "DirectoryOverrideSymlinkAndHardlink", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), fstest.Symlink("etc", "localetc"), fstest.Link("/etc/passwd", "/localetc/localpasswd"), ), w: tartest.TarAll( tc.Dir("/localetc/", 0755), tc.File("/localetc/localpasswd", []byte("different"), 0644), ), validator: notSameFile("/localetc/localpasswd", "/etc/passwd"), }, { name: "WhiteoutRootParent", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), ), w: tartest.TarAll( tc.File(".wh...", []byte{}, 0644), // Should wipe out whole directory ), err: errInvalidArchive, }, { name: "WhiteoutParent", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), ), w: tartest.TarAll( tc.File("etc/.wh...", []byte{}, 0644), ), err: errInvalidArchive, }, { name: "WhiteoutRoot", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), ), w: tartest.TarAll( tc.File(".wh..", []byte{}, 0644), ), err: errInvalidArchive, }, { name: "WhiteoutCurrentDirectory", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("inside"), 0644), ), w: tartest.TarAll( tc.File("etc/.wh..", []byte{}, 0644), // Should wipe out whole directory ), err: errInvalidArchive, }, { name: "WhiteoutSymlink", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("all users"), 0644), fstest.Symlink("/etc", "localetc"), ), w: tartest.TarAll( tc.File(".wh.localetc", []byte{}, 0644), // Should wipe out whole directory ), validator: all( fileValue("etc/passwd", []byte("all users")), fileNotExists("localetc"), ), }, { // TODO: This test should change once archive apply is disallowing // symlinks as parents in the name name: "WhiteoutSymlinkPath", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("all users"), 0644), fstest.CreateFile("/etc/whitedout", []byte("ahhhh whiteout"), 0644), fstest.Symlink("/etc", "localetc"), ), w: tartest.TarAll( tc.File("localetc/.wh.whitedout", []byte{}, 0644), ), validator: all( fileValue("etc/passwd", []byte("all users")), fileNotExists("etc/whitedout"), ), }, { name: "WhiteoutDirectoryName", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("all users"), 0644), fstest.CreateFile("/etc/whitedout", []byte("ahhhh whiteout"), 0644), fstest.Symlink("/etc", "localetc"), ), w: tartest.TarAll( tc.File(".wh.etc/somefile", []byte("non-empty"), 0644), ), validator: all( fileValue("etc/passwd", []byte("all users")), fileValue(".wh.etc/somefile", []byte("non-empty")), ), }, { name: "WhiteoutDeadSymlinkParent", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("all users"), 0644), fstest.Symlink("/dne", "localetc"), ), w: tartest.TarAll( tc.File("localetc/.wh.etc", []byte{}, 0644), ), // no-op, remove does not validator: fileValue("etc/passwd", []byte("all users")), }, { name: "WhiteoutRelativePath", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), fstest.CreateFile("/etc/passwd", []byte("all users"), 0644), fstest.Symlink("/dne", "localetc"), ), w: tartest.TarAll( tc.File("dne/../.wh.etc", []byte{}, 0644), ), // resolution ends up just removing etc validator: fileNotExists("etc/passwd"), }, { name: "HardlinkSymlinkChmod", w: func() tartest.WriterToTar { p := filepath.Join(td, "perm400") if err := ioutil.WriteFile(p, []byte("..."), 0400); err != nil { t.Fatal(err) } ep := filepath.Join(td, "also-exists-outside-root") if err := ioutil.WriteFile(ep, []byte("..."), 0640); err != nil { t.Fatal(err) } return tartest.TarAll( tc.Symlink(p, ep), tc.Link(ep, "sketchylink"), ) }(), validator: func(string) error { p := filepath.Join(td, "perm400") fi, err := os.Lstat(p) if err != nil { return err } if perm := fi.Mode() & os.ModePerm; perm != 0400 { return errors.Errorf("%s perm changed from 0400 to %04o", p, perm) } return nil }, }, } for _, bo := range breakouts { t.Run(bo.name, makeWriterToTarTest(bo.w, bo.apply, bo.validator, bo.err)) } } func TestDiffApply(t *testing.T) { fstest.FSSuite(t, diffApplier{}) } func TestApplyTar(t *testing.T) { tc := tartest.TarContext{}.WithUIDGID(os.Getuid(), os.Getgid()).WithModTime(time.Now().UTC()) directoriesExist := func(dirs ...string) func(string) error { return func(root string) error { for _, d := range dirs { p, err := fs.RootPath(root, d) if err != nil { return err } if _, err := os.Stat(p); err != nil { return errors.Wrapf(err, "failure checking existence for %v", d) } } return nil } } tests := []struct { name string w tartest.WriterToTar apply fstest.Applier validator func(string) error err error }{ { name: "DirectoryCreation", apply: fstest.Apply( fstest.CreateDir("/etc/", 0755), ), w: tartest.TarAll( tc.Dir("/etc/subdir", 0755), tc.Dir("/etc/subdir2/", 0755), tc.Dir("/etc/subdir2/more", 0755), tc.Dir("/other/noparent-1/1", 0755), tc.Dir("/other/noparent-2/2/", 0755), ), validator: directoriesExist( "etc/subdir", "etc/subdir2", "etc/subdir2/more", "other/noparent-1/1", "other/noparent-2/2", ), }, } for _, at := range tests { t.Run(at.name, makeWriterToTarTest(at.w, at.apply, at.validator, at.err)) } } func testApply(a fstest.Applier) error { td, err := ioutil.TempDir("", "test-apply-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(td) dest, err := ioutil.TempDir("", "test-apply-dest-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(dest) if err := a.Apply(td); err != nil { return errors.Wrap(err, "failed to apply filesystem changes") } tarArgs := []string{"c", "-C", td} names, err := readDirNames(td) if err != nil { return errors.Wrap(err, "failed to read directory names") } tarArgs = append(tarArgs, names...) cmd := exec.Command(tarCmd, tarArgs...) arch, err := cmd.StdoutPipe() if err != nil { return errors.Wrap(err, "failed to create stdout pipe") } if err := cmd.Start(); err != nil { return errors.Wrap(err, "failed to start command") } if _, err := Apply(context.Background(), dest, arch); err != nil { return errors.Wrap(err, "failed to apply tar stream") } return fstest.CheckDirectoryEqual(td, dest) } func testBaseDiff(a fstest.Applier) error { td, err := ioutil.TempDir("", "test-base-diff-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(td) dest, err := ioutil.TempDir("", "test-base-diff-dest-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(dest) if err := a.Apply(td); err != nil { return errors.Wrap(err, "failed to apply filesystem changes") } arch := Diff(context.Background(), "", td) cmd := exec.Command(tarCmd, "x", "-C", dest) cmd.Stdin = arch if err := cmd.Run(); err != nil { return errors.Wrap(err, "tar command failed") } return fstest.CheckDirectoryEqual(td, dest) } func testDiffApply(appliers ...fstest.Applier) error { td, err := ioutil.TempDir("", "test-diff-apply-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(td) dest, err := ioutil.TempDir("", "test-diff-apply-dest-") if err != nil { return errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(dest) for _, a := range appliers { if err := a.Apply(td); err != nil { return errors.Wrap(err, "failed to apply filesystem changes") } } // Apply base changes before diff if len(appliers) > 1 { for _, a := range appliers[:len(appliers)-1] { if err := a.Apply(dest); err != nil { return errors.Wrap(err, "failed to apply base filesystem changes") } } } diffBytes, err := ioutil.ReadAll(Diff(context.Background(), dest, td)) if err != nil { return errors.Wrap(err, "failed to create diff") } if _, err := Apply(context.Background(), dest, bytes.NewReader(diffBytes)); err != nil { return errors.Wrap(err, "failed to apply tar stream") } return fstest.CheckDirectoryEqual(td, dest) } func makeWriterToTarTest(wt tartest.WriterToTar, a fstest.Applier, validate func(string) error, applyErr error) func(*testing.T) { return func(t *testing.T) { td, err := ioutil.TempDir("", "test-writer-to-tar-") if err != nil { t.Fatalf("Failed to create temp dir: %v", err) } defer os.RemoveAll(td) if a != nil { if err := a.Apply(td); err != nil { t.Fatalf("Failed to apply filesystem to directory: %v", err) } } tr := tartest.TarFromWriterTo(wt) if _, err := Apply(context.Background(), td, tr); err != nil { if applyErr == nil { t.Fatalf("Failed to apply tar: %v", err) } else if !errors.Is(err, applyErr) { t.Fatalf("Unexpected apply error: %v, expected %v", err, applyErr) } return } else if applyErr != nil { t.Fatalf("Expected apply error, got none: %v", applyErr) } if validate != nil { if err := validate(td); err != nil { t.Errorf("Validation failed: %v", err) } } } } func TestDiffTar(t *testing.T) { tests := []struct { name string validators []tarEntryValidator a fstest.Applier b fstest.Applier }{ { name: "EmptyDiff", validators: []tarEntryValidator{}, a: fstest.Apply( fstest.CreateDir("/etc/", 0755), ), b: fstest.Apply(), }, { name: "ParentInclusion", validators: []tarEntryValidator{ dirEntry("d1/", 0755), dirEntry("d1/d/", 0700), dirEntry("d2/", 0770), fileEntry("d2/f", []byte("ok"), 0644), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateDir("/d2/", 0770), ), b: fstest.Apply( fstest.CreateDir("/d1/d", 0700), fstest.CreateFile("/d2/f", []byte("ok"), 0644), ), }, { name: "HardlinkParentInclusion", validators: []tarEntryValidator{ dirEntry("d2/", 0755), fileEntry("d2/l1", []byte("link me"), 0644), // d1/f1 and its parent is included after the new link, // before the new link was included, these files would // not have been needed dirEntry("d1/", 0755), linkEntry("d1/f1", "d2/l1"), dirEntry("d3/", 0755), fileEntry("d3/l1", []byte("link me"), 0644), dirEntry("d4/", 0755), linkEntry("d4/f1", "d3/l1"), dirEntry("d6/", 0755), whiteoutEntry("d6/l1"), whiteoutEntry("d6/l2"), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateFile("/d1/f1", []byte("link me"), 0644), fstest.CreateDir("/d2/", 0755), fstest.CreateFile("/d2/f1", []byte("link me"), 0644), fstest.CreateDir("/d3/", 0755), fstest.CreateDir("/d4/", 0755), fstest.CreateFile("/d4/f1", []byte("link me"), 0644), fstest.CreateDir("/d5/", 0755), fstest.CreateFile("/d5/f1", []byte("link me"), 0644), fstest.CreateDir("/d6/", 0755), fstest.Link("/d1/f1", "/d6/l1"), fstest.Link("/d5/f1", "/d6/l2"), ), b: fstest.Apply( fstest.Link("/d1/f1", "/d2/l1"), fstest.Link("/d4/f1", "/d3/l1"), fstest.Remove("/d6/l1"), fstest.Remove("/d6/l2"), ), }, { name: "UpdateDirectoryPermission", validators: []tarEntryValidator{ dirEntry("d1/", 0777), dirEntry("d1/d/", 0700), dirEntry("d2/", 0770), fileEntry("d2/f", []byte("ok"), 0644), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateDir("/d2/", 0770), ), b: fstest.Apply( fstest.Chmod("/d1", 0777), fstest.CreateDir("/d1/d", 0700), fstest.CreateFile("/d2/f", []byte("ok"), 0644), ), }, { name: "HardlinkUpdatedParent", validators: []tarEntryValidator{ dirEntry("d1/", 0777), dirEntry("d2/", 0755), fileEntry("d2/l1", []byte("link me"), 0644), // d1/f1 is included after the new link, its // parent has already changed and therefore // only the linked file is included linkEntry("d1/f1", "d2/l1"), dirEntry("d4/", 0777), fileEntry("d4/l1", []byte("link me"), 0644), dirEntry("d3/", 0755), linkEntry("d3/f1", "d4/l1"), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateFile("/d1/f1", []byte("link me"), 0644), fstest.CreateDir("/d2/", 0755), fstest.CreateFile("/d2/f1", []byte("link me"), 0644), fstest.CreateDir("/d3/", 0755), fstest.CreateFile("/d3/f1", []byte("link me"), 0644), fstest.CreateDir("/d4/", 0755), ), b: fstest.Apply( fstest.Chmod("/d1", 0777), fstest.Link("/d1/f1", "/d2/l1"), fstest.Chmod("/d4", 0777), fstest.Link("/d3/f1", "/d4/l1"), ), }, { name: "WhiteoutIncludesParents", validators: []tarEntryValidator{ dirEntry("d1/", 0755), whiteoutEntry("d1/f1"), dirEntry("d2/", 0755), whiteoutEntry("d2/f1"), fileEntry("d2/f2", []byte("content"), 0777), dirEntry("d3/", 0755), whiteoutEntry("d3/f1"), fileEntry("d3/f2", []byte("content"), 0644), dirEntry("d4/", 0755), fileEntry("d4/f0", []byte("content"), 0644), whiteoutEntry("d4/f1"), whiteoutEntry("d5"), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateFile("/d1/f1", []byte("content"), 0644), fstest.CreateDir("/d2/", 0755), fstest.CreateFile("/d2/f1", []byte("content"), 0644), fstest.CreateFile("/d2/f2", []byte("content"), 0644), fstest.CreateDir("/d3/", 0755), fstest.CreateFile("/d3/f1", []byte("content"), 0644), fstest.CreateDir("/d4/", 0755), fstest.CreateFile("/d4/f1", []byte("content"), 0644), fstest.CreateDir("/d5/", 0755), fstest.CreateFile("/d5/f1", []byte("content"), 0644), ), b: fstest.Apply( fstest.Remove("/d1/f1"), fstest.Remove("/d2/f1"), fstest.Chmod("/d2/f2", 0777), fstest.Remove("/d3/f1"), fstest.CreateFile("/d3/f2", []byte("content"), 0644), fstest.Remove("/d4/f1"), fstest.CreateFile("/d4/f0", []byte("content"), 0644), fstest.RemoveAll("/d5"), ), }, { name: "WhiteoutParentRemoval", validators: []tarEntryValidator{ whiteoutEntry("d1"), whiteoutEntry("d2"), dirEntry("d3/", 0755), }, a: fstest.Apply( fstest.CreateDir("/d1/", 0755), fstest.CreateDir("/d2/", 0755), fstest.CreateFile("/d2/f1", []byte("content"), 0644), ), b: fstest.Apply( fstest.RemoveAll("/d1"), fstest.RemoveAll("/d2"), fstest.CreateDir("/d3/", 0755), ), }, { name: "IgnoreSockets", validators: []tarEntryValidator{ fileEntry("f2", []byte("content"), 0644), // There should be _no_ socket here, despite the fstest.CreateSocket below fileEntry("f3", []byte("content"), 0644), }, a: fstest.Apply( fstest.CreateFile("/f1", []byte("content"), 0644), ), b: fstest.Apply( fstest.CreateFile("/f2", []byte("content"), 0644), fstest.CreateSocket("/s0", 0644), fstest.CreateFile("/f3", []byte("content"), 0644), ), }, } for _, at := range tests { t.Run(at.name, makeDiffTarTest(at.validators, at.a, at.b)) } } type tarEntryValidator func(*tar.Header, []byte) error func dirEntry(name string, mode int) tarEntryValidator { return func(hdr *tar.Header, b []byte) error { if hdr.Typeflag != tar.TypeDir { return errors.New("not directory type") } if hdr.Name != name { return errors.Errorf("wrong name %q, expected %q", hdr.Name, name) } if hdr.Mode != int64(mode) { return errors.Errorf("wrong mode %o, expected %o", hdr.Mode, mode) } return nil } } func fileEntry(name string, expected []byte, mode int) tarEntryValidator { return func(hdr *tar.Header, b []byte) error { if hdr.Typeflag != tar.TypeReg { return errors.New("not file type") } if hdr.Name != name { return errors.Errorf("wrong name %q, expected %q", hdr.Name, name) } if hdr.Mode != int64(mode) { return errors.Errorf("wrong mode %o, expected %o", hdr.Mode, mode) } if !bytes.Equal(b, expected) { return errors.Errorf("different file content") } return nil } } func linkEntry(name, link string) tarEntryValidator { return func(hdr *tar.Header, b []byte) error { if hdr.Typeflag != tar.TypeLink { return errors.New("not link type") } if hdr.Name != name { return errors.Errorf("wrong name %q, expected %q", hdr.Name, name) } if hdr.Linkname != link { return errors.Errorf("wrong link %q, expected %q", hdr.Linkname, link) } return nil } } func whiteoutEntry(name string) tarEntryValidator { whiteOutDir := filepath.Dir(name) whiteOutBase := filepath.Base(name) whiteOut := filepath.Join(whiteOutDir, whiteoutPrefix+whiteOutBase) return func(hdr *tar.Header, b []byte) error { if hdr.Typeflag != tar.TypeReg { return errors.Errorf("not file type: %q", hdr.Typeflag) } if hdr.Name != whiteOut { return errors.Errorf("wrong name %q, expected whiteout %q", hdr.Name, name) } return nil } } func makeDiffTarTest(validators []tarEntryValidator, a, b fstest.Applier) func(*testing.T) { return func(t *testing.T) { ad, err := ioutil.TempDir("", "test-make-diff-tar-") if err != nil { t.Fatalf("failed to create temp dir: %v", err) } defer os.RemoveAll(ad) if err := a.Apply(ad); err != nil { t.Fatalf("failed to apply a: %v", err) } bd, err := ioutil.TempDir("", "test-make-diff-tar-") if err != nil { t.Fatalf("failed to create temp dir: %v", err) } defer os.RemoveAll(bd) if err := fs.CopyDir(bd, ad); err != nil { t.Fatalf("failed to copy dir: %v", err) } if err := b.Apply(bd); err != nil { t.Fatalf("failed to apply b: %v", err) } rc := Diff(context.Background(), ad, bd) defer rc.Close() tr := tar.NewReader(rc) for i := 0; ; i++ { hdr, err := tr.Next() if err != nil { if err == io.EOF { break } t.Fatalf("tar read error: %v", err) } var b []byte if hdr.Typeflag == tar.TypeReg && hdr.Size > 0 { b, err = ioutil.ReadAll(tr) if err != nil { t.Fatalf("tar read file error: %v", err) } } if i >= len(validators) { t.Fatal("no validator for entry") } if err := validators[i](hdr, b); err != nil { t.Fatalf("tar entry[%d] validation fail: %#v", i, err) } } } } type diffApplier struct{} func (d diffApplier) TestContext(ctx context.Context) (context.Context, func(), error) { base, err := ioutil.TempDir("", "test-diff-apply-") if err != nil { return ctx, nil, errors.Wrap(err, "failed to create temp dir") } return context.WithValue(ctx, d, base), func() { os.RemoveAll(base) }, nil } func (d diffApplier) Apply(ctx context.Context, a fstest.Applier) (string, func(), error) { base := ctx.Value(d).(string) applyCopy, err := ioutil.TempDir("", "test-diffapply-apply-copy-") if err != nil { return "", nil, errors.Wrap(err, "failed to create temp dir") } defer os.RemoveAll(applyCopy) if err = fs.CopyDir(applyCopy, base); err != nil { return "", nil, errors.Wrap(err, "failed to copy base") } if err := a.Apply(applyCopy); err != nil { return "", nil, errors.Wrap(err, "failed to apply changes to copy of base") } diffBytes, err := ioutil.ReadAll(Diff(ctx, base, applyCopy)) if err != nil { return "", nil, errors.Wrap(err, "failed to create diff") } if _, err = Apply(ctx, base, bytes.NewReader(diffBytes)); err != nil { return "", nil, errors.Wrap(err, "failed to apply tar stream") } return base, nil, nil } func readDirNames(p string) ([]string, error) { fis, err := ioutil.ReadDir(p) if err != nil { return nil, err } names := make([]string, len(fis)) for i, fi := range fis { names[i] = fi.Name() } return names, nil } func requireTar(t *testing.T) { if _, err := exec.LookPath(tarCmd); err != nil { t.Skipf("%s not found, skipping", tarCmd) } } containerd-1.5.9/archive/tar_unix.go000066400000000000000000000120331416535272200174630ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 archive import ( "archive/tar" "os" "strings" "syscall" "github.com/containerd/containerd/pkg/userns" "github.com/containerd/continuity/fs" "github.com/containerd/continuity/sysx" "github.com/pkg/errors" "golang.org/x/sys/unix" ) func tarName(p string) (string, error) { return p, nil } func chmodTarEntry(perm os.FileMode) os.FileMode { return perm } func setHeaderForSpecialDevice(hdr *tar.Header, name string, fi os.FileInfo) error { s, ok := fi.Sys().(*syscall.Stat_t) if !ok { return errors.New("unsupported stat type") } // Rdev is int32 on darwin/bsd, int64 on linux/solaris rdev := uint64(s.Rdev) // nolint: unconvert // Currently go does not fill in the major/minors if s.Mode&syscall.S_IFBLK != 0 || s.Mode&syscall.S_IFCHR != 0 { hdr.Devmajor = int64(unix.Major(rdev)) hdr.Devminor = int64(unix.Minor(rdev)) } return nil } func open(p string) (*os.File, error) { return os.Open(p) } func openFile(name string, flag int, perm os.FileMode) (*os.File, error) { f, err := os.OpenFile(name, flag, perm) if err != nil { return nil, err } // Call chmod to avoid permission mask if err := os.Chmod(name, perm); err != nil { return nil, err } return f, err } func mkdir(path string, perm os.FileMode) error { if err := os.Mkdir(path, perm); err != nil { return err } // Only final created directory gets explicit permission // call to avoid permission mask return os.Chmod(path, perm) } func skipFile(hdr *tar.Header) bool { switch hdr.Typeflag { case tar.TypeBlock, tar.TypeChar: // cannot create a device if running in user namespace return userns.RunningInUserNS() default: return false } } // handleTarTypeBlockCharFifo is an OS-specific helper function used by // createTarFile to handle the following types of header: Block; Char; Fifo. // This function must not be called for Block and Char when running in userns. // (skipFile() should return true for them.) func handleTarTypeBlockCharFifo(hdr *tar.Header, path string) error { mode := uint32(hdr.Mode & 07777) switch hdr.Typeflag { case tar.TypeBlock: mode |= unix.S_IFBLK case tar.TypeChar: mode |= unix.S_IFCHR case tar.TypeFifo: mode |= unix.S_IFIFO } return mknod(path, mode, unix.Mkdev(uint32(hdr.Devmajor), uint32(hdr.Devminor))) } func getxattr(path, attr string) ([]byte, error) { b, err := sysx.LGetxattr(path, attr) if err == unix.ENOTSUP || err == sysx.ENODATA { return nil, nil } return b, err } func setxattr(path, key, value string) error { // Do not set trusted attributes if strings.HasPrefix(key, "trusted.") { return errors.Wrap(unix.ENOTSUP, "admin attributes from archive not supported") } return unix.Lsetxattr(path, key, []byte(value), 0) } func copyDirInfo(fi os.FileInfo, path string) error { st := fi.Sys().(*syscall.Stat_t) if err := os.Lchown(path, int(st.Uid), int(st.Gid)); err != nil { if os.IsPermission(err) { // Normally if uid/gid are the same this would be a no-op, but some // filesystems may still return EPERM... for instance NFS does this. // In such a case, this is not an error. if dstStat, err2 := os.Lstat(path); err2 == nil { st2 := dstStat.Sys().(*syscall.Stat_t) if st.Uid == st2.Uid && st.Gid == st2.Gid { err = nil } } } if err != nil { return errors.Wrapf(err, "failed to chown %s", path) } } if err := os.Chmod(path, fi.Mode()); err != nil { return errors.Wrapf(err, "failed to chmod %s", path) } timespec := []unix.Timespec{ unix.NsecToTimespec(syscall.TimespecToNsec(fs.StatAtime(st))), unix.NsecToTimespec(syscall.TimespecToNsec(fs.StatMtime(st))), } if err := unix.UtimesNanoAt(unix.AT_FDCWD, path, timespec, unix.AT_SYMLINK_NOFOLLOW); err != nil { return errors.Wrapf(err, "failed to utime %s", path) } return nil } func copyUpXAttrs(dst, src string) error { xattrKeys, err := sysx.LListxattr(src) if err != nil { if err == unix.ENOTSUP || err == sysx.ENODATA { return nil } return errors.Wrapf(err, "failed to list xattrs on %s", src) } for _, xattr := range xattrKeys { // Do not copy up trusted attributes if strings.HasPrefix(xattr, "trusted.") { continue } data, err := sysx.LGetxattr(src, xattr) if err != nil { if err == unix.ENOTSUP || err == sysx.ENODATA { continue } return errors.Wrapf(err, "failed to get xattr %q on %s", xattr, src) } if err := lsetxattrCreate(dst, xattr, data); err != nil { return errors.Wrapf(err, "failed to set xattr %q on %s", xattr, dst) } } return nil } containerd-1.5.9/archive/tar_windows.go000066400000000000000000000077571416535272200202130ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 archive import ( "archive/tar" "fmt" "os" "strings" "github.com/containerd/containerd/sys" "github.com/pkg/errors" ) // tarName returns platform-specific filepath // to canonical posix-style path for tar archival. p is relative // path. func tarName(p string) (string, error) { // windows: convert windows style relative path with backslashes // into forward slashes. Since windows does not allow '/' or '\' // in file names, it is mostly safe to replace however we must // check just in case if strings.Contains(p, "/") { return "", fmt.Errorf("windows path contains forward slash: %s", p) } return strings.Replace(p, string(os.PathSeparator), "/", -1), nil } // chmodTarEntry is used to adjust the file permissions used in tar header based // on the platform the archival is done. func chmodTarEntry(perm os.FileMode) os.FileMode { perm &= 0755 // Add the x bit: make everything +x from windows perm |= 0111 return perm } func setHeaderForSpecialDevice(*tar.Header, string, os.FileInfo) error { // do nothing. no notion of Rdev, Inode, Nlink in stat on Windows return nil } func open(p string) (*os.File, error) { // We use sys.OpenSequential to ensure we use sequential file // access on Windows to avoid depleting the standby list. return sys.OpenSequential(p) } func openFile(name string, flag int, perm os.FileMode) (*os.File, error) { // Source is regular file. We use sys.OpenFileSequential to use sequential // file access to avoid depleting the standby list on Windows. return sys.OpenFileSequential(name, flag, perm) } func mkdir(path string, perm os.FileMode) error { return os.Mkdir(path, perm) } func skipFile(hdr *tar.Header) bool { // Windows does not support filenames with colons in them. Ignore // these files. This is not a problem though (although it might // appear that it is). Let's suppose a client is running docker pull. // The daemon it points to is Windows. Would it make sense for the // client to be doing a docker pull Ubuntu for example (which has files // with colons in the name under /usr/share/man/man3)? No, absolutely // not as it would really only make sense that they were pulling a // Windows image. However, for development, it is necessary to be able // to pull Linux images which are in the repository. // // TODO Windows. Once the registry is aware of what images are Windows- // specific or Linux-specific, this warning should be changed to an error // to cater for the situation where someone does manage to upload a Linux // image but have it tagged as Windows inadvertently. return strings.Contains(hdr.Name, ":") } // handleTarTypeBlockCharFifo is an OS-specific helper function used by // createTarFile to handle the following types of header: Block; Char; Fifo func handleTarTypeBlockCharFifo(hdr *tar.Header, path string) error { return nil } func lchmod(path string, mode os.FileMode) error { return nil } func getxattr(path, attr string) ([]byte, error) { return nil, nil } func setxattr(path, key, value string) error { // Return not support error, do not wrap underlying not supported // since xattrs should not exist in windows diff archives return errors.New("xattrs not supported on Windows") } func copyDirInfo(fi os.FileInfo, path string) error { if err := os.Chmod(path, fi.Mode()); err != nil { return errors.Wrapf(err, "failed to chmod %s", path) } return nil } func copyUpXAttrs(dst, src string) error { return nil } containerd-1.5.9/archive/tartest/000077500000000000000000000000001416535272200167725ustar00rootroot00000000000000containerd-1.5.9/archive/tartest/tar.go000066400000000000000000000114651416535272200201160ustar00rootroot00000000000000/* Copyright The containerd 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 tartest import ( "archive/tar" "errors" "io" "os" "time" ) // WriterToTar is an type which writes to a tar writer type WriterToTar interface { WriteTo(*tar.Writer) error } type writerToFn func(*tar.Writer) error func (w writerToFn) WriteTo(tw *tar.Writer) error { return w(tw) } // TarAll creates a WriterToTar which calls all the provided writers // in the order in which they are provided. func TarAll(wt ...WriterToTar) WriterToTar { return writerToFn(func(tw *tar.Writer) error { for _, w := range wt { if err := w.WriteTo(tw); err != nil { return err } } return nil }) } // TarFromWriterTo is used to create a tar stream from a tar record // creator. This can be used to manufacture more specific tar records // which allow testing specific tar cases which may be encountered // by the untar process. func TarFromWriterTo(wt WriterToTar) io.ReadCloser { r, w := io.Pipe() go func() { tw := tar.NewWriter(w) if err := wt.WriteTo(tw); err != nil { w.CloseWithError(err) return } w.CloseWithError(tw.Close()) }() return r } // TarContext is used to create tar records type TarContext struct { UID int GID int // ModTime sets the modtimes for all files, if nil the current time // is used for each file when it was written ModTime *time.Time Xattrs map[string]string } func (tc TarContext) newHeader(mode os.FileMode, name, link string, size int64) *tar.Header { ti := tarInfo{ name: name, mode: mode, size: size, modt: tc.ModTime, hdr: &tar.Header{ Uid: tc.UID, Gid: tc.GID, Xattrs: tc.Xattrs, }, } if mode&os.ModeSymlink == 0 && link != "" { ti.hdr.Typeflag = tar.TypeLink ti.hdr.Linkname = link } hdr, err := tar.FileInfoHeader(ti, link) if err != nil { // Only returns an error on bad input mode panic(err) } return hdr } type tarInfo struct { name string mode os.FileMode size int64 modt *time.Time hdr *tar.Header } func (ti tarInfo) Name() string { return ti.name } func (ti tarInfo) Size() int64 { return ti.size } func (ti tarInfo) Mode() os.FileMode { return ti.mode } func (ti tarInfo) ModTime() time.Time { if ti.modt != nil { return *ti.modt } return time.Now().UTC() } func (ti tarInfo) IsDir() bool { return (ti.mode & os.ModeDir) != 0 } func (ti tarInfo) Sys() interface{} { return ti.hdr } // WithUIDGID sets the UID and GID for tar entries func (tc TarContext) WithUIDGID(uid, gid int) TarContext { ntc := tc ntc.UID = uid ntc.GID = gid return ntc } // WithModTime sets the ModTime for tar entries func (tc TarContext) WithModTime(modtime time.Time) TarContext { ntc := tc ntc.ModTime = &modtime return ntc } // WithXattrs adds these xattrs to all files, merges with any // previously added xattrs func (tc TarContext) WithXattrs(xattrs map[string]string) TarContext { ntc := tc if ntc.Xattrs == nil { ntc.Xattrs = map[string]string{} } for k, v := range xattrs { ntc.Xattrs[k] = v } return ntc } // File returns a regular file tar entry using the provided bytes func (tc TarContext) File(name string, content []byte, perm os.FileMode) WriterToTar { return writerToFn(func(tw *tar.Writer) error { return writeHeaderAndContent(tw, tc.newHeader(perm, name, "", int64(len(content))), content) }) } // Dir returns a directory tar entry func (tc TarContext) Dir(name string, perm os.FileMode) WriterToTar { return writerToFn(func(tw *tar.Writer) error { return writeHeaderAndContent(tw, tc.newHeader(perm|os.ModeDir, name, "", 0), nil) }) } // Symlink returns a symlink tar entry func (tc TarContext) Symlink(oldname, newname string) WriterToTar { return writerToFn(func(tw *tar.Writer) error { return writeHeaderAndContent(tw, tc.newHeader(0777|os.ModeSymlink, newname, oldname, 0), nil) }) } // Link returns a hard link tar entry func (tc TarContext) Link(oldname, newname string) WriterToTar { return writerToFn(func(tw *tar.Writer) error { return writeHeaderAndContent(tw, tc.newHeader(0777, newname, oldname, 0), nil) }) } func writeHeaderAndContent(tw *tar.Writer, h *tar.Header, b []byte) error { if h.Size != int64(len(b)) { return errors.New("bad content length") } if err := tw.WriteHeader(h); err != nil { return err } if len(b) > 0 { if _, err := tw.Write(b); err != nil { return err } } return nil } containerd-1.5.9/archive/time.go000066400000000000000000000022301416535272200165660ustar00rootroot00000000000000/* Copyright The containerd 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 archive import ( "syscall" "time" "unsafe" ) var ( minTime = time.Unix(0, 0) maxTime time.Time ) func init() { if unsafe.Sizeof(syscall.Timespec{}.Nsec) == 8 { // This is a 64 bit timespec // os.Chtimes limits time to the following maxTime = time.Unix(0, 1<<63-1) } else { // This is a 32 bit timespec maxTime = time.Unix(1<<31-1, 0) } } func boundTime(t time.Time) time.Time { if t.Before(minTime) || t.After(maxTime) { return minTime } return t } func latestTime(t1, t2 time.Time) time.Time { if t1.Before(t2) { return t2 } return t1 } containerd-1.5.9/archive/time_unix.go000066400000000000000000000020761416535272200176410ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 archive import ( "time" "golang.org/x/sys/unix" "github.com/pkg/errors" ) func chtimes(path string, atime, mtime time.Time) error { var utimes [2]unix.Timespec utimes[0] = unix.NsecToTimespec(atime.UnixNano()) utimes[1] = unix.NsecToTimespec(mtime.UnixNano()) if err := unix.UtimesNanoAt(unix.AT_FDCWD, path, utimes[0:], unix.AT_SYMLINK_NOFOLLOW); err != nil { return errors.Wrapf(err, "failed call to UtimesNanoAt for %s", path) } return nil } containerd-1.5.9/archive/time_windows.go000066400000000000000000000024571416535272200203530ustar00rootroot00000000000000/* Copyright The containerd 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 archive import ( "time" "golang.org/x/sys/windows" ) // chtimes will set the create time on a file using the given modtime. // This requires calling SetFileTime and explicitly including the create time. func chtimes(path string, atime, mtime time.Time) error { ctimespec := windows.NsecToTimespec(mtime.UnixNano()) pathp, e := windows.UTF16PtrFromString(path) if e != nil { return e } h, e := windows.CreateFile(pathp, windows.FILE_WRITE_ATTRIBUTES, windows.FILE_SHARE_WRITE, nil, windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS, 0) if e != nil { return e } defer windows.Close(h) c := windows.NsecToFiletime(windows.TimespecToNsec(ctimespec)) return windows.SetFileTime(h, &c, nil, nil) } containerd-1.5.9/cio/000077500000000000000000000000001416535272200144355ustar00rootroot00000000000000containerd-1.5.9/cio/io.go000066400000000000000000000165451416535272200154060ustar00rootroot00000000000000/* Copyright The containerd 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 cio import ( "context" "errors" "fmt" "io" "net/url" "os" "path/filepath" "strings" "sync" "github.com/containerd/containerd/defaults" ) var bufPool = sync.Pool{ New: func() interface{} { buffer := make([]byte, 32<<10) return &buffer }, } // Config holds the IO configurations. type Config struct { // Terminal is true if one has been allocated Terminal bool // Stdin path Stdin string // Stdout path Stdout string // Stderr path Stderr string } // IO holds the io information for a task or process type IO interface { // Config returns the IO configuration. Config() Config // Cancel aborts all current io operations. Cancel() // Wait blocks until all io copy operations have completed. Wait() // Close cleans up all open io resources. Cancel() is always called before // Close() Close() error } // Creator creates new IO sets for a task type Creator func(id string) (IO, error) // Attach allows callers to reattach to running tasks // // There should only be one reader for a task's IO set // because fifo's can only be read from one reader or the output // will be sent only to the first reads type Attach func(*FIFOSet) (IO, error) // FIFOSet is a set of file paths to FIFOs for a task's standard IO streams type FIFOSet struct { Config close func() error } // Close the FIFOSet func (f *FIFOSet) Close() error { if f != nil && f.close != nil { return f.close() } return nil } // NewFIFOSet returns a new FIFOSet from a Config and a close function func NewFIFOSet(config Config, close func() error) *FIFOSet { return &FIFOSet{Config: config, close: close} } // Streams used to configure a Creator or Attach type Streams struct { Stdin io.Reader Stdout io.Writer Stderr io.Writer Terminal bool FIFODir string } // Opt customize options for creating a Creator or Attach type Opt func(*Streams) // WithStdio sets stream options to the standard input/output streams func WithStdio(opt *Streams) { WithStreams(os.Stdin, os.Stdout, os.Stderr)(opt) } // WithTerminal sets the terminal option func WithTerminal(opt *Streams) { opt.Terminal = true } // WithStreams sets the stream options to the specified Reader and Writers func WithStreams(stdin io.Reader, stdout, stderr io.Writer) Opt { return func(opt *Streams) { opt.Stdin = stdin opt.Stdout = stdout opt.Stderr = stderr } } // WithFIFODir sets the fifo directory. // e.g. "/run/containerd/fifo", "/run/users/1001/containerd/fifo" func WithFIFODir(dir string) Opt { return func(opt *Streams) { opt.FIFODir = dir } } // NewCreator returns an IO creator from the options func NewCreator(opts ...Opt) Creator { streams := &Streams{} for _, opt := range opts { opt(streams) } if streams.FIFODir == "" { streams.FIFODir = defaults.DefaultFIFODir } return func(id string) (IO, error) { fifos, err := NewFIFOSetInDir(streams.FIFODir, id, streams.Terminal) if err != nil { return nil, err } if streams.Stdin == nil { fifos.Stdin = "" } if streams.Stdout == nil { fifos.Stdout = "" } if streams.Stderr == nil { fifos.Stderr = "" } return copyIO(fifos, streams) } } // NewAttach attaches the existing io for a task to the provided io.Reader/Writers func NewAttach(opts ...Opt) Attach { streams := &Streams{} for _, opt := range opts { opt(streams) } return func(fifos *FIFOSet) (IO, error) { if fifos == nil { return nil, fmt.Errorf("cannot attach, missing fifos") } return copyIO(fifos, streams) } } // NullIO redirects the container's IO into /dev/null func NullIO(_ string) (IO, error) { return &cio{}, nil } // cio is a basic container IO implementation. type cio struct { config Config wg *sync.WaitGroup closers []io.Closer cancel context.CancelFunc } func (c *cio) Config() Config { return c.config } func (c *cio) Wait() { if c.wg != nil { c.wg.Wait() } } func (c *cio) Close() error { var lastErr error for _, closer := range c.closers { if closer == nil { continue } if err := closer.Close(); err != nil { lastErr = err } } return lastErr } func (c *cio) Cancel() { if c.cancel != nil { c.cancel() } } type pipes struct { Stdin io.WriteCloser Stdout io.ReadCloser Stderr io.ReadCloser } // DirectIO allows task IO to be handled externally by the caller type DirectIO struct { pipes cio } var ( _ IO = &DirectIO{} _ IO = &logURI{} ) // LogURI provides the raw logging URI func LogURI(uri *url.URL) Creator { return func(_ string) (IO, error) { return &logURI{ config: Config{ Stdout: uri.String(), Stderr: uri.String(), }, }, nil } } // BinaryIO forwards container STDOUT|STDERR directly to a logging binary func BinaryIO(binary string, args map[string]string) Creator { return func(_ string) (IO, error) { uri, err := LogURIGenerator("binary", binary, args) if err != nil { return nil, err } res := uri.String() return &logURI{ config: Config{ Stdout: res, Stderr: res, }, }, nil } } // TerminalBinaryIO forwards container STDOUT|STDERR directly to a logging binary // It also sets the terminal option to true func TerminalBinaryIO(binary string, args map[string]string) Creator { return func(_ string) (IO, error) { uri, err := LogURIGenerator("binary", binary, args) if err != nil { return nil, err } res := uri.String() return &logURI{ config: Config{ Stdout: res, Stderr: res, Terminal: true, }, }, nil } } // LogFile creates a file on disk that logs the task's STDOUT,STDERR. // If the log file already exists, the logs will be appended to the file. func LogFile(path string) Creator { return func(_ string) (IO, error) { uri, err := LogURIGenerator("file", path, nil) if err != nil { return nil, err } res := uri.String() return &logURI{ config: Config{ Stdout: res, Stderr: res, }, }, nil } } // LogURIGenerator is the helper to generate log uri with specific scheme. func LogURIGenerator(scheme string, path string, args map[string]string) (*url.URL, error) { path = filepath.Clean(path) if !strings.HasPrefix(path, "/") { return nil, errors.New("absolute path needed") } uri := &url.URL{ Scheme: scheme, Path: path, } if len(args) == 0 { return uri, nil } q := uri.Query() for k, v := range args { q.Set(k, v) } uri.RawQuery = q.Encode() return uri, nil } type logURI struct { config Config } func (l *logURI) Config() Config { return l.config } func (l *logURI) Cancel() { } func (l *logURI) Wait() { } func (l *logURI) Close() error { return nil } // Load the io for a container but do not attach // // Allows io to be loaded on the task for deletion without // starting copy routines func Load(set *FIFOSet) (IO, error) { return &cio{ config: set.Config, closers: []io.Closer{set}, }, nil } func (p *pipes) closers() []io.Closer { return []io.Closer{p.Stdin, p.Stdout, p.Stderr} } containerd-1.5.9/cio/io_test.go000066400000000000000000000140671416535272200164420ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 cio import ( "bytes" "context" "io" "io/ioutil" "net/url" "os" "path/filepath" "runtime" "strings" "syscall" "testing" "github.com/containerd/fifo" "github.com/google/go-cmp/cmp/cmpopts" "gotest.tools/v3/assert" is "gotest.tools/v3/assert/cmp" ) func assertHasPrefix(t *testing.T, s, prefix string) { t.Helper() if !strings.HasPrefix(s, prefix) { t.Fatalf("expected %s to start with %s", s, prefix) } } func TestNewFIFOSetInDir(t *testing.T) { if runtime.GOOS == "windows" { t.Skip("NewFIFOSetInDir has different behaviour on windows") } root, err := ioutil.TempDir("", "test-new-fifo-set") assert.NilError(t, err) defer os.RemoveAll(root) fifos, err := NewFIFOSetInDir(root, "theid", true) assert.NilError(t, err) dir := filepath.Dir(fifos.Stdin) assertHasPrefix(t, dir, root) expected := &FIFOSet{ Config: Config{ Stdin: filepath.Join(dir, "theid-stdin"), Stdout: filepath.Join(dir, "theid-stdout"), Stderr: filepath.Join(dir, "theid-stderr"), Terminal: true, }, } assert.Assert(t, is.DeepEqual(fifos, expected, cmpFIFOSet)) files, err := ioutil.ReadDir(root) assert.NilError(t, err) assert.Check(t, is.Len(files, 1)) assert.NilError(t, fifos.Close()) files, err = ioutil.ReadDir(root) assert.NilError(t, err) assert.Check(t, is.Len(files, 0)) } var cmpFIFOSet = cmpopts.IgnoreUnexported(FIFOSet{}) func TestNewAttach(t *testing.T) { if runtime.GOOS == "windows" { t.Skip("setupFIFOProducers not yet implemented on windows") } var ( expectedStdin = "this is the stdin" expectedStdout = "this is the stdout" expectedStderr = "this is the stderr" stdin = bytes.NewBufferString(expectedStdin) stdout = new(bytes.Buffer) stderr = new(bytes.Buffer) ) withBytesBuffers := func(streams *Streams) { *streams = Streams{Stdin: stdin, Stdout: stdout, Stderr: stderr} } attacher := NewAttach(withBytesBuffers) fifos, err := NewFIFOSetInDir("", "theid", false) assert.NilError(t, err) io, err := attacher(fifos) assert.NilError(t, err) defer io.Close() producers := setupFIFOProducers(t, io.Config()) initProducers(t, producers, expectedStdout, expectedStderr) actualStdin, err := ioutil.ReadAll(producers.Stdin) assert.NilError(t, err) io.Wait() io.Cancel() assert.NilError(t, io.Close()) assert.Check(t, is.Equal(expectedStdout, stdout.String())) assert.Check(t, is.Equal(expectedStderr, stderr.String())) assert.Check(t, is.Equal(expectedStdin, string(actualStdin))) } type producers struct { Stdin io.ReadCloser Stdout io.WriteCloser Stderr io.WriteCloser } func setupFIFOProducers(t *testing.T, fifos Config) producers { var ( err error pipes producers ctx = context.Background() ) pipes.Stdin, err = fifo.OpenFifo(ctx, fifos.Stdin, syscall.O_RDONLY, 0) assert.NilError(t, err) pipes.Stdout, err = fifo.OpenFifo(ctx, fifos.Stdout, syscall.O_WRONLY, 0) assert.NilError(t, err) pipes.Stderr, err = fifo.OpenFifo(ctx, fifos.Stderr, syscall.O_WRONLY, 0) assert.NilError(t, err) return pipes } func initProducers(t *testing.T, producers producers, stdout, stderr string) { _, err := producers.Stdout.Write([]byte(stdout)) assert.NilError(t, err) assert.NilError(t, producers.Stdout.Close()) _, err = producers.Stderr.Write([]byte(stderr)) assert.NilError(t, err) assert.NilError(t, producers.Stderr.Close()) } func TestBinaryIOArgs(t *testing.T) { res, err := BinaryIO("/file.bin", map[string]string{"id": "1"})("") assert.NilError(t, err) assert.Equal(t, "binary:///file.bin?id=1", res.Config().Stdout) assert.Equal(t, "binary:///file.bin?id=1", res.Config().Stderr) } func TestBinaryIOAbsolutePath(t *testing.T) { res, err := BinaryIO("/full/path/bin", nil)("!") assert.NilError(t, err) // Test parse back parsed, err := url.Parse(res.Config().Stdout) assert.NilError(t, err) assert.Equal(t, "binary", parsed.Scheme) assert.Equal(t, "/full/path/bin", parsed.Path) } func TestBinaryIOFailOnRelativePath(t *testing.T) { _, err := BinaryIO("./bin", nil)("!") assert.Error(t, err, "absolute path needed") } func TestLogFileAbsolutePath(t *testing.T) { res, err := LogFile("/full/path/file.txt")("!") assert.NilError(t, err) assert.Equal(t, "file:///full/path/file.txt", res.Config().Stdout) assert.Equal(t, "file:///full/path/file.txt", res.Config().Stderr) // Test parse back parsed, err := url.Parse(res.Config().Stdout) assert.NilError(t, err) assert.Equal(t, "file", parsed.Scheme) assert.Equal(t, "/full/path/file.txt", parsed.Path) } func TestLogFileFailOnRelativePath(t *testing.T) { _, err := LogFile("./file.txt")("!") assert.Error(t, err, "absolute path needed") } func TestLogURIGenerator(t *testing.T) { for _, tc := range []struct { scheme string path string args map[string]string expected string err string }{ { scheme: "fifo", path: "/full/path/pipe.fifo", expected: "fifo:///full/path/pipe.fifo", }, { scheme: "file", path: "/full/path/file.txt", args: map[string]string{ "maxSize": "100MB", }, expected: "file:///full/path/file.txt?maxSize=100MB", }, { scheme: "binary", path: "/full/path/bin", args: map[string]string{ "id": "testing", }, expected: "binary:///full/path/bin?id=testing", }, { scheme: "unknown", path: "nowhere", err: "absolute path needed", }, } { uri, err := LogURIGenerator(tc.scheme, tc.path, tc.args) if err != nil { assert.Error(t, err, tc.err) continue } assert.Equal(t, tc.expected, uri.String()) } } containerd-1.5.9/cio/io_unix.go000066400000000000000000000073041416535272200164420ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 cio import ( "context" "io" "io/ioutil" "os" "path/filepath" "sync" "syscall" "github.com/containerd/fifo" "github.com/pkg/errors" ) // NewFIFOSetInDir returns a new FIFOSet with paths in a temporary directory under root func NewFIFOSetInDir(root, id string, terminal bool) (*FIFOSet, error) { if root != "" { if err := os.MkdirAll(root, 0700); err != nil { return nil, err } } dir, err := ioutil.TempDir(root, "") if err != nil { return nil, err } closer := func() error { return os.RemoveAll(dir) } return NewFIFOSet(Config{ Stdin: filepath.Join(dir, id+"-stdin"), Stdout: filepath.Join(dir, id+"-stdout"), Stderr: filepath.Join(dir, id+"-stderr"), Terminal: terminal, }, closer), nil } func copyIO(fifos *FIFOSet, ioset *Streams) (*cio, error) { var ctx, cancel = context.WithCancel(context.Background()) pipes, err := openFifos(ctx, fifos) if err != nil { cancel() return nil, err } if fifos.Stdin != "" { go func() { p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(pipes.Stdin, ioset.Stdin, *p) pipes.Stdin.Close() }() } var wg = &sync.WaitGroup{} if fifos.Stdout != "" { wg.Add(1) go func() { p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(ioset.Stdout, pipes.Stdout, *p) pipes.Stdout.Close() wg.Done() }() } if !fifos.Terminal && fifos.Stderr != "" { wg.Add(1) go func() { p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(ioset.Stderr, pipes.Stderr, *p) pipes.Stderr.Close() wg.Done() }() } return &cio{ config: fifos.Config, wg: wg, closers: append(pipes.closers(), fifos), cancel: cancel, }, nil } func openFifos(ctx context.Context, fifos *FIFOSet) (f pipes, retErr error) { defer func() { if retErr != nil { fifos.Close() } }() if fifos.Stdin != "" { if f.Stdin, retErr = fifo.OpenFifo(ctx, fifos.Stdin, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); retErr != nil { return f, errors.Wrapf(retErr, "failed to open stdin fifo") } defer func() { if retErr != nil && f.Stdin != nil { f.Stdin.Close() } }() } if fifos.Stdout != "" { if f.Stdout, retErr = fifo.OpenFifo(ctx, fifos.Stdout, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); retErr != nil { return f, errors.Wrapf(retErr, "failed to open stdout fifo") } defer func() { if retErr != nil && f.Stdout != nil { f.Stdout.Close() } }() } if !fifos.Terminal && fifos.Stderr != "" { if f.Stderr, retErr = fifo.OpenFifo(ctx, fifos.Stderr, syscall.O_RDONLY|syscall.O_CREAT|syscall.O_NONBLOCK, 0700); retErr != nil { return f, errors.Wrapf(retErr, "failed to open stderr fifo") } } return f, nil } // NewDirectIO returns an IO implementation that exposes the IO streams as io.ReadCloser // and io.WriteCloser. func NewDirectIO(ctx context.Context, fifos *FIFOSet) (*DirectIO, error) { ctx, cancel := context.WithCancel(ctx) pipes, err := openFifos(ctx, fifos) return &DirectIO{ pipes: pipes, cio: cio{ config: fifos.Config, closers: append(pipes.closers(), fifos), cancel: cancel, }, }, err } containerd-1.5.9/cio/io_unix_test.go000066400000000000000000000046631416535272200175060ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 cio import ( "context" "fmt" "io/ioutil" "os" "path/filepath" "testing" "gotest.tools/v3/assert" ) func TestOpenFifos(t *testing.T) { scenarios := []*FIFOSet{ { Config: Config{ Stdin: "", Stdout: filepath.Join("This/does/not/exist", "test-stdout"), Stderr: filepath.Join("This/does/not/exist", "test-stderr"), }, }, { Config: Config{ Stdin: filepath.Join("This/does/not/exist", "test-stdin"), Stdout: "", Stderr: filepath.Join("This/does/not/exist", "test-stderr"), }, }, { Config: Config{ Stdin: "", Stdout: "", Stderr: filepath.Join("This/does/not/exist", "test-stderr"), }, }, } for _, scenario := range scenarios { _, err := openFifos(context.Background(), scenario) assert.Assert(t, err != nil, scenario) } } // TestOpenFifosWithTerminal tests openFifos should not open stderr if terminal // is set. func TestOpenFifosWithTerminal(t *testing.T) { var ctx, cancel = context.WithCancel(context.Background()) defer cancel() ioFifoDir, err := ioutil.TempDir("", fmt.Sprintf("cio-%s", t.Name())) if err != nil { t.Fatalf("unexpected error during creating temp dir: %v", err) } defer os.RemoveAll(ioFifoDir) cfg := Config{ Stdout: filepath.Join(ioFifoDir, "test-stdout"), Stderr: filepath.Join(ioFifoDir, "test-stderr"), } // Without terminal, pipes.Stderr should not be nil { p, err := openFifos(ctx, NewFIFOSet(cfg, nil)) if err != nil { t.Fatalf("unexpected error during openFifos: %v", err) } if p.Stderr == nil { t.Fatalf("unexpected empty stderr pipe") } } // With terminal, pipes.Stderr should be nil { cfg.Terminal = true p, err := openFifos(ctx, NewFIFOSet(cfg, nil)) if err != nil { t.Fatalf("unexpected error during openFifos: %v", err) } if p.Stderr != nil { t.Fatalf("unexpected stderr pipe") } } } containerd-1.5.9/cio/io_windows.go000066400000000000000000000073521416535272200171540ustar00rootroot00000000000000/* Copyright The containerd 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 cio import ( "context" "fmt" "io" winio "github.com/Microsoft/go-winio" "github.com/containerd/containerd/log" "github.com/pkg/errors" ) const pipeRoot = `\\.\pipe` // NewFIFOSetInDir returns a new set of fifos for the task func NewFIFOSetInDir(_, id string, terminal bool) (*FIFOSet, error) { stderrPipe := "" if !terminal { stderrPipe = fmt.Sprintf(`%s\ctr-%s-stderr`, pipeRoot, id) } return NewFIFOSet(Config{ Terminal: terminal, Stdin: fmt.Sprintf(`%s\ctr-%s-stdin`, pipeRoot, id), Stdout: fmt.Sprintf(`%s\ctr-%s-stdout`, pipeRoot, id), Stderr: stderrPipe, }, nil), nil } func copyIO(fifos *FIFOSet, ioset *Streams) (_ *cio, retErr error) { cios := &cio{config: fifos.Config} defer func() { if retErr != nil { _ = cios.Close() } }() if fifos.Stdin != "" { l, err := winio.ListenPipe(fifos.Stdin, nil) if err != nil { return nil, errors.Wrapf(err, "failed to create stdin pipe %s", fifos.Stdin) } cios.closers = append(cios.closers, l) go func() { c, err := l.Accept() if err != nil { log.L.WithError(err).Errorf("failed to accept stdin connection on %s", fifos.Stdin) return } p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(c, ioset.Stdin, *p) c.Close() l.Close() }() } if fifos.Stdout != "" { l, err := winio.ListenPipe(fifos.Stdout, nil) if err != nil { return nil, errors.Wrapf(err, "failed to create stdout pipe %s", fifos.Stdout) } cios.closers = append(cios.closers, l) go func() { c, err := l.Accept() if err != nil { log.L.WithError(err).Errorf("failed to accept stdout connection on %s", fifos.Stdout) return } p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(ioset.Stdout, c, *p) c.Close() l.Close() }() } if fifos.Stderr != "" { l, err := winio.ListenPipe(fifos.Stderr, nil) if err != nil { return nil, errors.Wrapf(err, "failed to create stderr pipe %s", fifos.Stderr) } cios.closers = append(cios.closers, l) go func() { c, err := l.Accept() if err != nil { log.L.WithError(err).Errorf("failed to accept stderr connection on %s", fifos.Stderr) return } p := bufPool.Get().(*[]byte) defer bufPool.Put(p) io.CopyBuffer(ioset.Stderr, c, *p) c.Close() l.Close() }() } return cios, nil } // NewDirectIO returns an IO implementation that exposes the IO streams as io.ReadCloser // and io.WriteCloser. func NewDirectIO(stdin io.WriteCloser, stdout, stderr io.ReadCloser, terminal bool) *DirectIO { return &DirectIO{ pipes: pipes{ Stdin: stdin, Stdout: stdout, Stderr: stderr, }, cio: cio{ config: Config{Terminal: terminal}, }, } } // NewDirectIOFromFIFOSet returns an IO implementation that exposes the IO streams as io.ReadCloser // and io.WriteCloser. func NewDirectIOFromFIFOSet(ctx context.Context, stdin io.WriteCloser, stdout, stderr io.ReadCloser, fifos *FIFOSet) *DirectIO { _, cancel := context.WithCancel(ctx) pipes := pipes{ Stdin: stdin, Stdout: stdout, Stderr: stderr, } return &DirectIO{ pipes: pipes, cio: cio{ config: fifos.Config, closers: append(pipes.closers(), fifos), cancel: cancel, }, } } containerd-1.5.9/cio/io_windows_test.go000066400000000000000000000030451416535272200202060ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 cio import ( "testing" "gotest.tools/v3/assert" ) func TestNewFifoSetInDir_NoTerminal(t *testing.T) { set, err := NewFIFOSetInDir("", t.Name(), false) if err != nil { t.Fatalf("NewFifoSetInDir failed with: %v", err) } assert.Assert(t, !set.Terminal, "FIFOSet.Terminal should be false") assert.Assert(t, set.Stdin != "", "FIFOSet.Stdin should be set") assert.Assert(t, set.Stdout != "", "FIFOSet.Stdout should be set") assert.Assert(t, set.Stderr != "", "FIFOSet.Stderr should be set") } func TestNewFifoSetInDir_Terminal(t *testing.T) { set, err := NewFIFOSetInDir("", t.Name(), true) if err != nil { t.Fatalf("NewFifoSetInDir failed with: %v", err) } assert.Assert(t, set.Terminal, "FIFOSet.Terminal should be false") assert.Assert(t, set.Stdin != "", "FIFOSet.Stdin should be set") assert.Assert(t, set.Stdout != "", "FIFOSet.Stdout should be set") assert.Assert(t, set.Stderr == "", "FIFOSet.Stderr should not be set") } containerd-1.5.9/client.go000066400000000000000000000604171416535272200155000ustar00rootroot00000000000000/* Copyright The containerd 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 containerd import ( "bytes" "context" "encoding/json" "fmt" "net/http" "runtime" "strconv" "strings" "sync" "time" containersapi "github.com/containerd/containerd/api/services/containers/v1" contentapi "github.com/containerd/containerd/api/services/content/v1" diffapi "github.com/containerd/containerd/api/services/diff/v1" eventsapi "github.com/containerd/containerd/api/services/events/v1" imagesapi "github.com/containerd/containerd/api/services/images/v1" introspectionapi "github.com/containerd/containerd/api/services/introspection/v1" leasesapi "github.com/containerd/containerd/api/services/leases/v1" namespacesapi "github.com/containerd/containerd/api/services/namespaces/v1" snapshotsapi "github.com/containerd/containerd/api/services/snapshots/v1" "github.com/containerd/containerd/api/services/tasks/v1" versionservice "github.com/containerd/containerd/api/services/version/v1" apitypes "github.com/containerd/containerd/api/types" "github.com/containerd/containerd/containers" "github.com/containerd/containerd/content" contentproxy "github.com/containerd/containerd/content/proxy" "github.com/containerd/containerd/defaults" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/events" "github.com/containerd/containerd/images" "github.com/containerd/containerd/leases" leasesproxy "github.com/containerd/containerd/leases/proxy" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/pkg/dialer" "github.com/containerd/containerd/platforms" "github.com/containerd/containerd/plugin" "github.com/containerd/containerd/remotes" "github.com/containerd/containerd/remotes/docker" "github.com/containerd/containerd/services/introspection" "github.com/containerd/containerd/snapshots" snproxy "github.com/containerd/containerd/snapshots/proxy" "github.com/containerd/typeurl" ptypes "github.com/gogo/protobuf/types" ocispec "github.com/opencontainers/image-spec/specs-go/v1" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/pkg/errors" "golang.org/x/sync/semaphore" "google.golang.org/grpc" "google.golang.org/grpc/backoff" "google.golang.org/grpc/health/grpc_health_v1" ) func init() { const prefix = "types.containerd.io" // register TypeUrls for commonly marshaled external types major := strconv.Itoa(specs.VersionMajor) typeurl.Register(&specs.Spec{}, prefix, "opencontainers/runtime-spec", major, "Spec") typeurl.Register(&specs.Process{}, prefix, "opencontainers/runtime-spec", major, "Process") typeurl.Register(&specs.LinuxResources{}, prefix, "opencontainers/runtime-spec", major, "LinuxResources") typeurl.Register(&specs.WindowsResources{}, prefix, "opencontainers/runtime-spec", major, "WindowsResources") } // New returns a new containerd client that is connected to the containerd // instance provided by address func New(address string, opts ...ClientOpt) (*Client, error) { var copts clientOpts for _, o := range opts { if err := o(&copts); err != nil { return nil, err } } if copts.timeout == 0 { copts.timeout = 10 * time.Second } c := &Client{ defaultns: copts.defaultns, } if copts.defaultRuntime != "" { c.runtime = copts.defaultRuntime } else { c.runtime = defaults.DefaultRuntime } if copts.defaultPlatform != nil { c.platform = copts.defaultPlatform } else { c.platform = platforms.Default() } if copts.services != nil { c.services = *copts.services } if address != "" { backoffConfig := backoff.DefaultConfig backoffConfig.MaxDelay = 3 * time.Second connParams := grpc.ConnectParams{ Backoff: backoffConfig, } gopts := []grpc.DialOption{ grpc.WithBlock(), grpc.WithInsecure(), grpc.FailOnNonTempDialError(true), grpc.WithConnectParams(connParams), grpc.WithContextDialer(dialer.ContextDialer), // TODO(stevvooe): We may need to allow configuration of this on the client. grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(defaults.DefaultMaxRecvMsgSize)), grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(defaults.DefaultMaxSendMsgSize)), } if len(copts.dialOptions) > 0 { gopts = copts.dialOptions } if copts.defaultns != "" { unary, stream := newNSInterceptors(copts.defaultns) gopts = append(gopts, grpc.WithUnaryInterceptor(unary), grpc.WithStreamInterceptor(stream), ) } connector := func() (*grpc.ClientConn, error) { ctx, cancel := context.WithTimeout(context.Background(), copts.timeout) defer cancel() conn, err := grpc.DialContext(ctx, dialer.DialAddress(address), gopts...) if err != nil { return nil, errors.Wrapf(err, "failed to dial %q", address) } return conn, nil } conn, err := connector() if err != nil { return nil, err } c.conn, c.connector = conn, connector } if copts.services == nil && c.conn == nil { return nil, errors.Wrap(errdefs.ErrUnavailable, "no grpc connection or services is available") } // check namespace labels for default runtime if copts.defaultRuntime == "" && c.defaultns != "" { if label, err := c.GetLabel(context.Background(), defaults.DefaultRuntimeNSLabel); err != nil { return nil, err } else if label != "" { c.runtime = label } } return c, nil } // NewWithConn returns a new containerd client that is connected to the containerd // instance provided by the connection func NewWithConn(conn *grpc.ClientConn, opts ...ClientOpt) (*Client, error) { var copts clientOpts for _, o := range opts { if err := o(&copts); err != nil { return nil, err } } c := &Client{ defaultns: copts.defaultns, conn: conn, runtime: fmt.Sprintf("%s.%s", plugin.RuntimePlugin, runtime.GOOS), } // check namespace labels for default runtime if copts.defaultRuntime == "" && c.defaultns != "" { if label, err := c.GetLabel(context.Background(), defaults.DefaultRuntimeNSLabel); err != nil { return nil, err } else if label != "" { c.runtime = label } } if copts.services != nil { c.services = *copts.services } return c, nil } // Client is the client to interact with containerd and its various services // using a uniform interface type Client struct { services connMu sync.Mutex conn *grpc.ClientConn runtime string defaultns string platform platforms.MatchComparer connector func() (*grpc.ClientConn, error) } // Reconnect re-establishes the GRPC connection to the containerd daemon func (c *Client) Reconnect() error { if c.connector == nil { return errors.Wrap(errdefs.ErrUnavailable, "unable to reconnect to containerd, no connector available") } c.connMu.Lock() defer c.connMu.Unlock() c.conn.Close() conn, err := c.connector() if err != nil { return err } c.conn = conn return nil } // Runtime returns the name of the runtime being used func (c *Client) Runtime() string { return c.runtime } // IsServing returns true if the client can successfully connect to the // containerd daemon and the healthcheck service returns the SERVING // response. // This call will block if a transient error is encountered during // connection. A timeout can be set in the context to ensure it returns // early. func (c *Client) IsServing(ctx context.Context) (bool, error) { c.connMu.Lock() if c.conn == nil { c.connMu.Unlock() return false, errors.Wrap(errdefs.ErrUnavailable, "no grpc connection available") } c.connMu.Unlock() r, err := c.HealthService().Check(ctx, &grpc_health_v1.HealthCheckRequest{}, grpc.WaitForReady(true)) if err != nil { return false, err } return r.Status == grpc_health_v1.HealthCheckResponse_SERVING, nil } // Containers returns all containers created in containerd func (c *Client) Containers(ctx context.Context, filters ...string) ([]Container, error) { r, err := c.ContainerService().List(ctx, filters...) if err != nil { return nil, err } var out []Container for _, container := range r { out = append(out, containerFromRecord(c, container)) } return out, nil } // NewContainer will create a new container in container with the provided id // the id must be unique within the namespace func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error) { ctx, done, err := c.WithLease(ctx) if err != nil { return nil, err } defer done(ctx) container := containers.Container{ ID: id, Runtime: containers.RuntimeInfo{ Name: c.runtime, }, } for _, o := range opts { if err := o(ctx, c, &container); err != nil { return nil, err } } r, err := c.ContainerService().Create(ctx, container) if err != nil { return nil, err } return containerFromRecord(c, r), nil } // LoadContainer loads an existing container from metadata func (c *Client) LoadContainer(ctx context.Context, id string) (Container, error) { r, err := c.ContainerService().Get(ctx, id) if err != nil { return nil, err } return containerFromRecord(c, r), nil } // RemoteContext is used to configure object resolutions and transfers with // remote content stores and image providers. type RemoteContext struct { // Resolver is used to resolve names to objects, fetchers, and pushers. // If no resolver is provided, defaults to Docker registry resolver. Resolver remotes.Resolver // PlatformMatcher is used to match the platforms for an image // operation and define the preference when a single match is required // from multiple platforms. PlatformMatcher platforms.MatchComparer // Unpack is done after an image is pulled to extract into a snapshotter. // It is done simultaneously for schema 2 images when they are pulled. // If an image is not unpacked on pull, it can be unpacked any time // afterwards. Unpacking is required to run an image. Unpack bool // UnpackOpts handles options to the unpack call. UnpackOpts []UnpackOpt // Snapshotter used for unpacking Snapshotter string // SnapshotterOpts are additional options to be passed to a snapshotter during pull SnapshotterOpts []snapshots.Opt // Labels to be applied to the created image Labels map[string]string // BaseHandlers are a set of handlers which get are called on dispatch. // These handlers always get called before any operation specific // handlers. BaseHandlers []images.Handler // HandlerWrapper wraps the handler which gets sent to dispatch. // Unlike BaseHandlers, this can run before and after the built // in handlers, allowing operations to run on the descriptor // after it has completed transferring. HandlerWrapper func(images.Handler) images.Handler // ConvertSchema1 is whether to convert Docker registry schema 1 // manifests. If this option is false then any image which resolves // to schema 1 will return an error since schema 1 is not supported. ConvertSchema1 bool // Platforms defines which platforms to handle when doing the image operation. // Platforms is ignored when a PlatformMatcher is set, otherwise the // platforms will be used to create a PlatformMatcher with no ordering // preference. Platforms []string // MaxConcurrentDownloads is the max concurrent content downloads for each pull. MaxConcurrentDownloads int // MaxConcurrentUploadedLayers is the max concurrent uploaded layers for each push. MaxConcurrentUploadedLayers int // AllMetadata downloads all manifests and known-configuration files AllMetadata bool // ChildLabelMap sets the labels used to reference child objects in the content // store. By default, all GC reference labels will be set for all fetched content. ChildLabelMap func(ocispec.Descriptor) []string } func defaultRemoteContext() *RemoteContext { return &RemoteContext{ Resolver: docker.NewResolver(docker.ResolverOptions{ Client: http.DefaultClient, }), } } // Fetch downloads the provided content into containerd's content store // and returns a non-platform specific image reference func (c *Client) Fetch(ctx context.Context, ref string, opts ...RemoteOpt) (images.Image, error) { fetchCtx := defaultRemoteContext() for _, o := range opts { if err := o(c, fetchCtx); err != nil { return images.Image{}, err } } if fetchCtx.Unpack { return images.Image{}, errors.Wrap(errdefs.ErrNotImplemented, "unpack on fetch not supported, try pull") } if fetchCtx.PlatformMatcher == nil { if len(fetchCtx.Platforms) == 0 { fetchCtx.PlatformMatcher = platforms.All } else { var ps []ocispec.Platform for _, s := range fetchCtx.Platforms { p, err := platforms.Parse(s) if err != nil { return images.Image{}, errors.Wrapf(err, "invalid platform %s", s) } ps = append(ps, p) } fetchCtx.PlatformMatcher = platforms.Any(ps...) } } ctx, done, err := c.WithLease(ctx) if err != nil { return images.Image{}, err } defer done(ctx) img, err := c.fetch(ctx, fetchCtx, ref, 0) if err != nil { return images.Image{}, err } return c.createNewImage(ctx, img) } // Push uploads the provided content to a remote resource func (c *Client) Push(ctx context.Context, ref string, desc ocispec.Descriptor, opts ...RemoteOpt) error { pushCtx := defaultRemoteContext() for _, o := range opts { if err := o(c, pushCtx); err != nil { return err } } if pushCtx.PlatformMatcher == nil { if len(pushCtx.Platforms) > 0 { var ps []ocispec.Platform for _, platform := range pushCtx.Platforms { p, err := platforms.Parse(platform) if err != nil { return errors.Wrapf(err, "invalid platform %s", platform) } ps = append(ps, p) } pushCtx.PlatformMatcher = platforms.Any(ps...) } else { pushCtx.PlatformMatcher = platforms.All } } // Annotate ref with digest to push only push tag for single digest if !strings.Contains(ref, "@") { ref = ref + "@" + desc.Digest.String() } pusher, err := pushCtx.Resolver.Pusher(ctx, ref) if err != nil { return err } var wrapper func(images.Handler) images.Handler if len(pushCtx.BaseHandlers) > 0 { wrapper = func(h images.Handler) images.Handler { h = images.Handlers(append(pushCtx.BaseHandlers, h)...) if pushCtx.HandlerWrapper != nil { h = pushCtx.HandlerWrapper(h) } return h } } else if pushCtx.HandlerWrapper != nil { wrapper = pushCtx.HandlerWrapper } var limiter *semaphore.Weighted if pushCtx.MaxConcurrentUploadedLayers > 0 { limiter = semaphore.NewWeighted(int64(pushCtx.MaxConcurrentUploadedLayers)) } return remotes.PushContent(ctx, pusher, desc, c.ContentStore(), limiter, pushCtx.PlatformMatcher, wrapper) } // GetImage returns an existing image func (c *Client) GetImage(ctx context.Context, ref string) (Image, error) { i, err := c.ImageService().Get(ctx, ref) if err != nil { return nil, err } return NewImage(c, i), nil } // ListImages returns all existing images func (c *Client) ListImages(ctx context.Context, filters ...string) ([]Image, error) { imgs, err := c.ImageService().List(ctx, filters...) if err != nil { return nil, err } images := make([]Image, len(imgs)) for i, img := range imgs { images[i] = NewImage(c, img) } return images, nil } // Restore restores a container from a checkpoint func (c *Client) Restore(ctx context.Context, id string, checkpoint Image, opts ...RestoreOpts) (Container, error) { store := c.ContentStore() index, err := decodeIndex(ctx, store, checkpoint.Target()) if err != nil { return nil, err } ctx, done, err := c.WithLease(ctx) if err != nil { return nil, err } defer done(ctx) copts := []NewContainerOpts{} for _, o := range opts { copts = append(copts, o(ctx, id, c, checkpoint, index)) } ctr, err := c.NewContainer(ctx, id, copts...) if err != nil { return nil, err } return ctr, nil } func writeIndex(ctx context.Context, index *ocispec.Index, client *Client, ref string) (d ocispec.Descriptor, err error) { labels := map[string]string{} for i, m := range index.Manifests { labels[fmt.Sprintf("containerd.io/gc.ref.content.%d", i)] = m.Digest.String() } data, err := json.Marshal(index) if err != nil { return ocispec.Descriptor{}, err } return writeContent(ctx, client.ContentStore(), ocispec.MediaTypeImageIndex, ref, bytes.NewReader(data), content.WithLabels(labels)) } // GetLabel gets a label value from namespace store // If there is no default label, an empty string returned with nil error func (c *Client) GetLabel(ctx context.Context, label string) (string, error) { ns, err := namespaces.NamespaceRequired(ctx) if err != nil { if c.defaultns == "" { return "", err } ns = c.defaultns } srv := c.NamespaceService() labels, err := srv.Labels(ctx, ns) if err != nil { return "", err } value := labels[label] return value, nil } // Subscribe to events that match one or more of the provided filters. // // Callers should listen on both the envelope and errs channels. If the errs // channel returns nil or an error, the subscriber should terminate. // // The subscriber can stop receiving events by canceling the provided context. // The errs channel will be closed and return a nil error. func (c *Client) Subscribe(ctx context.Context, filters ...string) (ch <-chan *events.Envelope, errs <-chan error) { return c.EventService().Subscribe(ctx, filters...) } // Close closes the clients connection to containerd func (c *Client) Close() error { c.connMu.Lock() defer c.connMu.Unlock() if c.conn != nil { return c.conn.Close() } return nil } // NamespaceService returns the underlying Namespaces Store func (c *Client) NamespaceService() namespaces.Store { if c.namespaceStore != nil { return c.namespaceStore } c.connMu.Lock() defer c.connMu.Unlock() return NewNamespaceStoreFromClient(namespacesapi.NewNamespacesClient(c.conn)) } // ContainerService returns the underlying container Store func (c *Client) ContainerService() containers.Store { if c.containerStore != nil { return c.containerStore } c.connMu.Lock() defer c.connMu.Unlock() return NewRemoteContainerStore(containersapi.NewContainersClient(c.conn)) } // ContentStore returns the underlying content Store func (c *Client) ContentStore() content.Store { if c.contentStore != nil { return c.contentStore } c.connMu.Lock() defer c.connMu.Unlock() return contentproxy.NewContentStore(contentapi.NewContentClient(c.conn)) } // SnapshotService returns the underlying snapshotter for the provided snapshotter name func (c *Client) SnapshotService(snapshotterName string) snapshots.Snapshotter { snapshotterName, err := c.resolveSnapshotterName(context.Background(), snapshotterName) if err != nil { snapshotterName = DefaultSnapshotter } if c.snapshotters != nil { return c.snapshotters[snapshotterName] } c.connMu.Lock() defer c.connMu.Unlock() return snproxy.NewSnapshotter(snapshotsapi.NewSnapshotsClient(c.conn), snapshotterName) } // TaskService returns the underlying TasksClient func (c *Client) TaskService() tasks.TasksClient { if c.taskService != nil { return c.taskService } c.connMu.Lock() defer c.connMu.Unlock() return tasks.NewTasksClient(c.conn) } // ImageService returns the underlying image Store func (c *Client) ImageService() images.Store { if c.imageStore != nil { return c.imageStore } c.connMu.Lock() defer c.connMu.Unlock() return NewImageStoreFromClient(imagesapi.NewImagesClient(c.conn)) } // DiffService returns the underlying Differ func (c *Client) DiffService() DiffService { if c.diffService != nil { return c.diffService } c.connMu.Lock() defer c.connMu.Unlock() return NewDiffServiceFromClient(diffapi.NewDiffClient(c.conn)) } // IntrospectionService returns the underlying Introspection Client func (c *Client) IntrospectionService() introspection.Service { if c.introspectionService != nil { return c.introspectionService } c.connMu.Lock() defer c.connMu.Unlock() return introspection.NewIntrospectionServiceFromClient(introspectionapi.NewIntrospectionClient(c.conn)) } // LeasesService returns the underlying Leases Client func (c *Client) LeasesService() leases.Manager { if c.leasesService != nil { return c.leasesService } c.connMu.Lock() defer c.connMu.Unlock() return leasesproxy.NewLeaseManager(leasesapi.NewLeasesClient(c.conn)) } // HealthService returns the underlying GRPC HealthClient func (c *Client) HealthService() grpc_health_v1.HealthClient { c.connMu.Lock() defer c.connMu.Unlock() return grpc_health_v1.NewHealthClient(c.conn) } // EventService returns the underlying event service func (c *Client) EventService() EventService { if c.eventService != nil { return c.eventService } c.connMu.Lock() defer c.connMu.Unlock() return NewEventServiceFromClient(eventsapi.NewEventsClient(c.conn)) } // VersionService returns the underlying VersionClient func (c *Client) VersionService() versionservice.VersionClient { c.connMu.Lock() defer c.connMu.Unlock() return versionservice.NewVersionClient(c.conn) } // Conn returns the underlying GRPC connection object func (c *Client) Conn() *grpc.ClientConn { c.connMu.Lock() defer c.connMu.Unlock() return c.conn } // Version of containerd type Version struct { // Version number Version string // Revision from git that was built Revision string } // Version returns the version of containerd that the client is connected to func (c *Client) Version(ctx context.Context) (Version, error) { c.connMu.Lock() if c.conn == nil { c.connMu.Unlock() return Version{}, errors.Wrap(errdefs.ErrUnavailable, "no grpc connection available") } c.connMu.Unlock() response, err := c.VersionService().Version(ctx, &ptypes.Empty{}) if err != nil { return Version{}, err } return Version{ Version: response.Version, Revision: response.Revision, }, nil } // ServerInfo represents the introspected server information type ServerInfo struct { UUID string } // Server returns server information from the introspection service func (c *Client) Server(ctx context.Context) (ServerInfo, error) { c.connMu.Lock() if c.conn == nil { c.connMu.Unlock() return ServerInfo{}, errors.Wrap(errdefs.ErrUnavailable, "no grpc connection available") } c.connMu.Unlock() response, err := c.IntrospectionService().Server(ctx, &ptypes.Empty{}) if err != nil { return ServerInfo{}, err } return ServerInfo{ UUID: response.UUID, }, nil } func (c *Client) resolveSnapshotterName(ctx context.Context, name string) (string, error) { if name == "" { label, err := c.GetLabel(ctx, defaults.DefaultSnapshotterNSLabel) if err != nil { return "", err } if label != "" { name = label } else { name = DefaultSnapshotter } } return name, nil } func (c *Client) getSnapshotter(ctx context.Context, name string) (snapshots.Snapshotter, error) { name, err := c.resolveSnapshotterName(ctx, name) if err != nil { return nil, err } s := c.SnapshotService(name) if s == nil { return nil, errors.Wrapf(errdefs.ErrNotFound, "snapshotter %s was not found", name) } return s, nil } // CheckRuntime returns true if the current runtime matches the expected // runtime. Providing various parts of the runtime schema will match those // parts of the expected runtime func CheckRuntime(current, expected string) bool { cp := strings.Split(current, ".") l := len(cp) for i, p := range strings.Split(expected, ".") { if i > l { return false } if p != cp[i] { return false } } return true } // GetSnapshotterSupportedPlatforms returns a platform matchers which represents the // supported platforms for the given snapshotters func (c *Client) GetSnapshotterSupportedPlatforms(ctx context.Context, snapshotterName string) (platforms.MatchComparer, error) { filters := []string{fmt.Sprintf("type==%s, id==%s", plugin.SnapshotPlugin, snapshotterName)} in := c.IntrospectionService() resp, err := in.Plugins(ctx, filters) if err != nil { return nil, err } if len(resp.Plugins) <= 0 { return nil, fmt.Errorf("inspection service could not find snapshotter %s plugin", snapshotterName) } sn := resp.Plugins[0] snPlatforms := toPlatforms(sn.Platforms) return platforms.Any(snPlatforms...), nil } func toPlatforms(pt []apitypes.Platform) []ocispec.Platform { platforms := make([]ocispec.Platform, len(pt)) for i, p := range pt { platforms[i] = ocispec.Platform{ Architecture: p.Architecture, OS: p.OS, Variant: p.Variant, } } return platforms } containerd-1.5.9/client_opts.go000066400000000000000000000152471416535272200165460ustar00rootroot00000000000000/* Copyright The containerd 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 containerd import ( "time" "github.com/containerd/containerd/images" "github.com/containerd/containerd/platforms" "github.com/containerd/containerd/remotes" "github.com/containerd/containerd/snapshots" ocispec "github.com/opencontainers/image-spec/specs-go/v1" "google.golang.org/grpc" ) type clientOpts struct { defaultns string defaultRuntime string defaultPlatform platforms.MatchComparer services *services dialOptions []grpc.DialOption timeout time.Duration } // ClientOpt allows callers to set options on the containerd client type ClientOpt func(c *clientOpts) error // WithDefaultNamespace sets the default namespace on the client // // Any operation that does not have a namespace set on the context will // be provided the default namespace func WithDefaultNamespace(ns string) ClientOpt { return func(c *clientOpts) error { c.defaultns = ns return nil } } // WithDefaultRuntime sets the default runtime on the client func WithDefaultRuntime(rt string) ClientOpt { return func(c *clientOpts) error { c.defaultRuntime = rt return nil } } // WithDefaultPlatform sets the default platform matcher on the client func WithDefaultPlatform(platform platforms.MatchComparer) ClientOpt { return func(c *clientOpts) error { c.defaultPlatform = platform return nil } } // WithDialOpts allows grpc.DialOptions to be set on the connection func WithDialOpts(opts []grpc.DialOption) ClientOpt { return func(c *clientOpts) error { c.dialOptions = opts return nil } } // WithServices sets services used by the client. func WithServices(opts ...ServicesOpt) ClientOpt { return func(c *clientOpts) error { c.services = &services{} for _, o := range opts { o(c.services) } return nil } } // WithTimeout sets the connection timeout for the client func WithTimeout(d time.Duration) ClientOpt { return func(c *clientOpts) error { c.timeout = d return nil } } // RemoteOpt allows the caller to set distribution options for a remote type RemoteOpt func(*Client, *RemoteContext) error // WithPlatform allows the caller to specify a platform to retrieve // content for func WithPlatform(platform string) RemoteOpt { if platform == "" { platform = platforms.DefaultString() } return func(_ *Client, c *RemoteContext) error { for _, p := range c.Platforms { if p == platform { return nil } } c.Platforms = append(c.Platforms, platform) return nil } } // WithPlatformMatcher specifies the matcher to use for // determining which platforms to pull content for. // This value supersedes anything set with `WithPlatform`. func WithPlatformMatcher(m platforms.MatchComparer) RemoteOpt { return func(_ *Client, c *RemoteContext) error { c.PlatformMatcher = m return nil } } // WithPullUnpack is used to unpack an image after pull. This // uses the snapshotter, content store, and diff service // configured for the client. func WithPullUnpack(_ *Client, c *RemoteContext) error { c.Unpack = true return nil } // WithUnpackOpts is used to add unpack options to the unpacker. func WithUnpackOpts(opts []UnpackOpt) RemoteOpt { return func(_ *Client, c *RemoteContext) error { c.UnpackOpts = append(c.UnpackOpts, opts...) return nil } } // WithPullSnapshotter specifies snapshotter name used for unpacking. func WithPullSnapshotter(snapshotterName string, opts ...snapshots.Opt) RemoteOpt { return func(_ *Client, c *RemoteContext) error { c.Snapshotter = snapshotterName c.SnapshotterOpts = opts return nil } } // WithPullLabel sets a label to be associated with a pulled reference func WithPullLabel(key, value string) RemoteOpt { return func(_ *Client, rc *RemoteContext) error { if rc.Labels == nil { rc.Labels = make(map[string]string) } rc.Labels[key] = value return nil } } // WithPullLabels associates a set of labels to a pulled reference func WithPullLabels(labels map[string]string) RemoteOpt { return func(_ *Client, rc *RemoteContext) error { if rc.Labels == nil { rc.Labels = make(map[string]string) } for k, v := range labels { rc.Labels[k] = v } return nil } } // WithChildLabelMap sets the map function used to define the labels set // on referenced child content in the content store. This can be used // to overwrite the default GC labels or filter which labels get set // for content. // The default is `images.ChildGCLabels`. func WithChildLabelMap(fn func(ocispec.Descriptor) []string) RemoteOpt { return func(_ *Client, c *RemoteContext) error { c.ChildLabelMap = fn return nil } } // WithSchema1Conversion is used to convert Docker registry schema 1 // manifests to oci manifests on pull. Without this option schema 1 // manifests will return a not supported error. func WithSchema1Conversion(client *Client, c *RemoteContext) error { c.ConvertSchema1 = true return nil } // WithResolver specifies the resolver to use. func WithResolver(resolver remotes.Resolver) RemoteOpt { return func(client *Client, c *RemoteContext) error { c.Resolver = resolver return nil } } // WithImageHandler adds a base handler to be called on dispatch. func WithImageHandler(h images.Handler) RemoteOpt { return func(client *Client, c *RemoteContext) error { c.BaseHandlers = append(c.BaseHandlers, h) return nil } } // WithImageHandlerWrapper wraps the handlers to be called on dispatch. func WithImageHandlerWrapper(w func(images.Handler) images.Handler) RemoteOpt { return func(client *Client, c *RemoteContext) error { c.HandlerWrapper = w return nil } } // WithMaxConcurrentDownloads sets max concurrent download limit. func WithMaxConcurrentDownloads(max int) RemoteOpt { return func(client *Client, c *RemoteContext) error { c.MaxConcurrentDownloads = max return nil } } // WithMaxConcurrentUploadedLayers sets max concurrent uploaded layer limit. func WithMaxConcurrentUploadedLayers(max int) RemoteOpt { return func(client *Client, c *RemoteContext) error { c.MaxConcurrentUploadedLayers = max return nil } } // WithAllMetadata downloads all manifests and known-configuration files func WithAllMetadata() RemoteOpt { return func(_ *Client, c *RemoteContext) error { c.AllMetadata = true return nil } } containerd-1.5.9/cluster/000077500000000000000000000000001416535272200153445ustar00rootroot00000000000000containerd-1.5.9/cluster/gce000077700000000000000000000000001416535272200203542../contrib/gceustar00rootroot00000000000000containerd-1.5.9/cmd/000077500000000000000000000000001416535272200144265ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd-shim-runc-v1/000077500000000000000000000000001416535272200210035ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd-shim-runc-v1/main.go000066400000000000000000000014501416535272200222560ustar00rootroot00000000000000// +build linux /* Copyright The containerd 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 main import ( v1 "github.com/containerd/containerd/runtime/v2/runc/v1" "github.com/containerd/containerd/runtime/v2/shim" ) func main() { shim.Run("io.containerd.runc.v1", v1.New) } containerd-1.5.9/cmd/containerd-shim-runc-v2/000077500000000000000000000000001416535272200210045ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd-shim-runc-v2/main.go000066400000000000000000000014501416535272200222570ustar00rootroot00000000000000// +build linux /* Copyright The containerd 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 main import ( v2 "github.com/containerd/containerd/runtime/v2/runc/v2" "github.com/containerd/containerd/runtime/v2/shim" ) func main() { shim.Run("io.containerd.runc.v2", v2.New) } containerd-1.5.9/cmd/containerd-shim/000077500000000000000000000000001416535272200175125ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd-shim/main_unix.go000066400000000000000000000204301416535272200220270ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 main import ( "bytes" "context" "flag" "fmt" "io" "net" "os" "os/exec" "os/signal" "runtime" "runtime/debug" "strings" "sync" "syscall" "time" "github.com/containerd/containerd/events" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/pkg/process" shimlog "github.com/containerd/containerd/runtime/v1" "github.com/containerd/containerd/runtime/v1/shim" shimapi "github.com/containerd/containerd/runtime/v1/shim/v1" "github.com/containerd/containerd/sys/reaper" "github.com/containerd/ttrpc" "github.com/containerd/typeurl" ptypes "github.com/gogo/protobuf/types" "github.com/pkg/errors" "github.com/sirupsen/logrus" "golang.org/x/sys/unix" ) var ( debugFlag bool namespaceFlag string socketFlag string addressFlag string workdirFlag string runtimeRootFlag string criuFlag string systemdCgroupFlag bool containerdBinaryFlag string bufPool = sync.Pool{ New: func() interface{} { return bytes.NewBuffer(nil) }, } ) func init() { flag.BoolVar(&debugFlag, "debug", false, "enable debug output in logs") flag.StringVar(&namespaceFlag, "namespace", "", "namespace that owns the shim") flag.StringVar(&socketFlag, "socket", "", "socket path to serve") flag.StringVar(&addressFlag, "address", "", "grpc address back to main containerd") flag.StringVar(&workdirFlag, "workdir", "", "path used to storge large temporary data") flag.StringVar(&runtimeRootFlag, "runtime-root", process.RuncRoot, "root directory for the runtime") flag.StringVar(&criuFlag, "criu", "", "path to criu binary") flag.BoolVar(&systemdCgroupFlag, "systemd-cgroup", false, "set runtime to use systemd-cgroup") // currently, the `containerd publish` utility is embedded in the daemon binary. // The daemon invokes `containerd-shim -containerd-binary ...` with its own os.Executable() path. flag.StringVar(&containerdBinaryFlag, "containerd-binary", "containerd", "path to containerd binary (used for `containerd publish`)") flag.Parse() } func main() { debug.SetGCPercent(40) go func() { for range time.Tick(30 * time.Second) { debug.FreeOSMemory() } }() if debugFlag { logrus.SetLevel(logrus.DebugLevel) } if os.Getenv("GOMAXPROCS") == "" { // If GOMAXPROCS hasn't been set, we default to a value of 2 to reduce // the number of Go stacks present in the shim. runtime.GOMAXPROCS(2) } stdout, stderr, err := openStdioKeepAlivePipes(workdirFlag) if err != nil { fmt.Fprintf(os.Stderr, "containerd-shim: %s\n", err) os.Exit(1) } defer func() { stdout.Close() stderr.Close() }() // redirect the following output into fifo to make sure that containerd // still can read the log after restart logrus.SetOutput(stdout) if err := executeShim(); err != nil { fmt.Fprintf(os.Stderr, "containerd-shim: %s\n", err) os.Exit(1) } } // If containerd server process dies, we need the shim to keep stdout/err reader // FDs so that Linux does not SIGPIPE the shim process if it tries to use its end of // these pipes. func openStdioKeepAlivePipes(dir string) (io.ReadWriteCloser, io.ReadWriteCloser, error) { background := context.Background() keepStdoutAlive, err := shimlog.OpenShimStdoutLog(background, dir) if err != nil { return nil, nil, err } keepStderrAlive, err := shimlog.OpenShimStderrLog(background, dir) if err != nil { return nil, nil, err } return keepStdoutAlive, keepStderrAlive, nil } func executeShim() error { // start handling signals as soon as possible so that things are properly reaped // or if runtime exits before we hit the handler signals, err := setupSignals() if err != nil { return err } dump := make(chan os.Signal, 32) signal.Notify(dump, syscall.SIGUSR1) path, err := os.Getwd() if err != nil { return err } server, err := newServer() if err != nil { return errors.Wrap(err, "failed creating server") } sv, err := shim.NewService( shim.Config{ Path: path, Namespace: namespaceFlag, WorkDir: workdirFlag, Criu: criuFlag, SystemdCgroup: systemdCgroupFlag, RuntimeRoot: runtimeRootFlag, }, &remoteEventsPublisher{address: addressFlag}, ) if err != nil { return err } logrus.Debug("registering ttrpc server") shimapi.RegisterShimService(server, sv) socket := socketFlag if err := serve(context.Background(), server, socket); err != nil { return err } logger := logrus.WithFields(logrus.Fields{ "pid": os.Getpid(), "path": path, "namespace": namespaceFlag, }) go func() { for range dump { dumpStacks(logger) } }() return handleSignals(logger, signals, server, sv) } // serve serves the ttrpc API over a unix socket at the provided path // this function does not block func serve(ctx context.Context, server *ttrpc.Server, path string) error { var ( l net.Listener err error ) if path == "" { f := os.NewFile(3, "socket") l, err = net.FileListener(f) f.Close() path = "[inherited from parent]" } else { const ( abstractSocketPrefix = "\x00" socketPathLimit = 106 ) p := strings.TrimPrefix(path, "unix://") if len(p) == len(path) { p = abstractSocketPrefix + p } if len(p) > socketPathLimit { return errors.Errorf("%q: unix socket path too long (> %d)", p, socketPathLimit) } l, err = net.Listen("unix", p) } if err != nil { return err } logrus.WithField("socket", path).Debug("serving api on unix socket") go func() { defer l.Close() if err := server.Serve(ctx, l); err != nil && !strings.Contains(err.Error(), "use of closed network connection") { logrus.WithError(err).Fatal("containerd-shim: ttrpc server failure") } }() return nil } func handleSignals(logger *logrus.Entry, signals chan os.Signal, server *ttrpc.Server, sv *shim.Service) error { var ( termOnce sync.Once done = make(chan struct{}) ) for { select { case <-done: return nil case s := <-signals: switch s { case unix.SIGCHLD: if err := reaper.Reap(); err != nil { logger.WithError(err).Error("reap exit status") } case unix.SIGTERM, unix.SIGINT: go termOnce.Do(func() { ctx := context.TODO() if err := server.Shutdown(ctx); err != nil { logger.WithError(err).Error("failed to shutdown server") } // Ensure our child is dead if any sv.Kill(ctx, &shimapi.KillRequest{ Signal: uint32(syscall.SIGKILL), All: true, }) sv.Delete(context.Background(), &ptypes.Empty{}) close(done) }) case unix.SIGPIPE: } } } } func dumpStacks(logger *logrus.Entry) { var ( buf []byte stackSize int ) bufferLen := 16384 for stackSize == len(buf) { buf = make([]byte, bufferLen) stackSize = runtime.Stack(buf, true) bufferLen *= 2 } buf = buf[:stackSize] logger.Infof("=== BEGIN goroutine stack dump ===\n%s\n=== END goroutine stack dump ===", buf) } type remoteEventsPublisher struct { address string } func (l *remoteEventsPublisher) Publish(ctx context.Context, topic string, event events.Event) error { ns, _ := namespaces.Namespace(ctx) encoded, err := typeurl.MarshalAny(event) if err != nil { return err } data, err := encoded.Marshal() if err != nil { return err } cmd := exec.CommandContext(ctx, containerdBinaryFlag, "--address", l.address, "publish", "--topic", topic, "--namespace", ns) cmd.Stdin = bytes.NewReader(data) b := bufPool.Get().(*bytes.Buffer) defer func() { b.Reset() bufPool.Put(b) }() cmd.Stdout = b cmd.Stderr = b c, err := reaper.Default.Start(cmd) if err != nil { return err } status, err := reaper.Default.Wait(cmd, c) if err != nil { return errors.Wrapf(err, "failed to publish event: %s", b.String()) } if status != 0 { return errors.Errorf("failed to publish event: %s", b.String()) } return nil } containerd-1.5.9/cmd/containerd-shim/shim_darwin.go000066400000000000000000000026451416535272200223540ustar00rootroot00000000000000// +build darwin /* Copyright The containerd 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 main import ( "os" "os/signal" "github.com/containerd/containerd/sys/reaper" runc "github.com/containerd/go-runc" "github.com/containerd/ttrpc" ) // setupSignals creates a new signal handler for all signals and sets the shim as a // sub-reaper so that the container processes are reparented func setupSignals() (chan os.Signal, error) { signals := make(chan os.Signal, 2048) signal.Notify(signals) // make sure runc is setup to use the monitor // for waiting on processes runc.Monitor = reaper.Default return signals, nil } func newServer() (*ttrpc.Server, error) { // for darwin, we omit the socket credentials because these syscalls are // slightly different. since we don't have darwin support yet, this can be // implemented later and the build can continue without issue. return ttrpc.NewServer() } containerd-1.5.9/cmd/containerd-shim/shim_freebsd.go000066400000000000000000000026511416535272200224770ustar00rootroot00000000000000// +build freebsd /* Copyright The containerd 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 main import ( "os" "os/signal" "github.com/containerd/containerd/sys/reaper" runc "github.com/containerd/go-runc" "github.com/containerd/ttrpc" ) // setupSignals creates a new signal handler for all signals and sets the shim as a // sub-reaper so that the container processes are reparented func setupSignals() (chan os.Signal, error) { signals := make(chan os.Signal, 2048) signal.Notify(signals) // make sure runc is setup to use the monitor // for waiting on processes runc.Monitor = reaper.Default return signals, nil } func newServer() (*ttrpc.Server, error) { // for freebsd, we omit the socket credentials because these syscalls are // slightly different. since we don't have freebsd support yet, this can be // implemented later and the build can continue without issue. return ttrpc.NewServer() } containerd-1.5.9/cmd/containerd-shim/shim_linux.go000066400000000000000000000027431416535272200222260ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "os" "os/signal" "github.com/containerd/containerd/sys/reaper" runc "github.com/containerd/go-runc" "github.com/containerd/ttrpc" "golang.org/x/sys/unix" ) // setupSignals creates a new signal handler for all signals and sets the shim as a // sub-reaper so that the container processes are reparented func setupSignals() (chan os.Signal, error) { signals := make(chan os.Signal, 32) signal.Notify(signals, unix.SIGTERM, unix.SIGINT, unix.SIGCHLD, unix.SIGPIPE) // make sure runc is setup to use the monitor // for waiting on processes runc.Monitor = reaper.Default // set the shim as the subreaper for all orphaned processes created by the container if err := reaper.SetSubreaper(1); err != nil { return nil, err } return signals, nil } func newServer() (*ttrpc.Server, error) { return ttrpc.NewServer(ttrpc.WithServerHandshaker(ttrpc.UnixSocketRequireSameUser())) } containerd-1.5.9/cmd/containerd-stress/000077500000000000000000000000001416535272200200755ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd-stress/density.go000066400000000000000000000134021416535272200221030ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "bufio" "context" "encoding/json" "fmt" "io/ioutil" "os" "os/signal" "path/filepath" "strconv" "strings" "syscall" "github.com/containerd/containerd" "github.com/containerd/containerd/cio" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/oci" "github.com/sirupsen/logrus" "github.com/urfave/cli" ) var densityCommand = cli.Command{ Name: "density", Usage: "stress tests density of containers running on a system", Flags: []cli.Flag{ cli.IntFlag{ Name: "count", Usage: "number of containers to run", Value: 10, }, }, Action: func(cliContext *cli.Context) error { config := config{ Address: cliContext.GlobalString("address"), Duration: cliContext.GlobalDuration("duration"), Concurrency: cliContext.GlobalInt("concurrent"), Exec: cliContext.GlobalBool("exec"), JSON: cliContext.GlobalBool("json"), Metrics: cliContext.GlobalString("metrics"), Snapshotter: cliContext.GlobalString("snapshotter"), } client, err := config.newClient() if err != nil { return err } defer client.Close() ctx := namespaces.WithNamespace(context.Background(), "density") if err := cleanup(ctx, client); err != nil { return err } logrus.Infof("pulling %s", imageName) image, err := client.Pull(ctx, imageName, containerd.WithPullUnpack, containerd.WithPullSnapshotter(config.Snapshotter)) if err != nil { return err } logrus.Info("generating spec from image") s := make(chan os.Signal, 1) signal.Notify(s, syscall.SIGTERM, syscall.SIGINT) if err != nil { return err } var ( pids []uint32 count = cliContext.Int("count") ) loop: for i := 0; i < count+1; i++ { select { case <-s: break loop default: id := fmt.Sprintf("density-%d", i) c, err := client.NewContainer(ctx, id, containerd.WithSnapshotter(config.Snapshotter), containerd.WithNewSnapshot(id, image), containerd.WithNewSpec( oci.WithImageConfig(image), oci.WithProcessArgs("sleep", "120m"), oci.WithUsername("games")), ) if err != nil { return err } defer c.Delete(ctx, containerd.WithSnapshotCleanup) t, err := c.NewTask(ctx, cio.NullIO) if err != nil { return err } defer t.Delete(ctx, containerd.WithProcessKill) if err := t.Start(ctx); err != nil { return err } pids = append(pids, t.Pid()) } } var results struct { PSS int `json:"pss"` RSS int `json:"rss"` PSSPerContainer int `json:"pssPerContainer"` RSSPerContainer int `json:"rssPerContainer"` } for _, pid := range pids { shimPid, err := getppid(int(pid)) if err != nil { return err } smaps, err := getMaps(shimPid) if err != nil { return err } results.RSS += smaps["Rss:"] results.PSS += smaps["Pss:"] } results.PSSPerContainer = results.PSS / count results.RSSPerContainer = results.RSS / count return json.NewEncoder(os.Stdout).Encode(results) }, } func getMaps(pid int) (map[string]int, error) { f, err := os.Open(fmt.Sprintf("/proc/%d/smaps", pid)) if err != nil { return nil, err } defer f.Close() var ( smaps = make(map[string]int) s = bufio.NewScanner(f) ) for s.Scan() { var ( fields = strings.Fields(s.Text()) name = fields[0] ) if len(fields) < 2 { continue } n, err := strconv.Atoi(fields[1]) if err != nil { continue } smaps[name] += n } if err := s.Err(); err != nil { return nil, err } return smaps, nil } func getppid(pid int) (int, error) { bytes, err := ioutil.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "stat")) if err != nil { return 0, err } s, err := parseStat(string(bytes)) if err != nil { return 0, err } return int(s.PPID), nil } // Stat represents the information from /proc/[pid]/stat, as // described in proc(5) with names based on the /proc/[pid]/status // fields. type Stat struct { // PID is the process ID. PID uint // Name is the command run by the process. Name string // StartTime is the number of clock ticks after system boot (since // Linux 2.6). StartTime uint64 // Parent process ID. PPID uint } func parseStat(data string) (stat Stat, err error) { // From proc(5), field 2 could contain space and is inside `(` and `)`. // The following is an example: // 89653 (gunicorn: maste) S 89630 89653 89653 0 -1 4194560 29689 28896 0 3 146 32 76 19 20 0 1 0 2971844 52965376 3920 18446744073709551615 1 1 0 0 0 0 0 16781312 137447943 0 0 0 17 1 0 0 0 0 0 0 0 0 0 0 0 0 0 i := strings.LastIndex(data, ")") if i <= 2 || i >= len(data)-1 { return stat, fmt.Errorf("invalid stat data: %q", data) } parts := strings.SplitN(data[:i], "(", 2) if len(parts) != 2 { return stat, fmt.Errorf("invalid stat data: %q", data) } stat.Name = parts[1] _, err = fmt.Sscanf(parts[0], "%d", &stat.PID) if err != nil { return stat, err } // parts indexes should be offset by 3 from the field number given // proc(5), because parts is zero-indexed and we've removed fields // one (PID) and two (Name) in the paren-split. parts = strings.Split(data[i+2:], " ") fmt.Sscanf(parts[22-3], "%d", &stat.StartTime) fmt.Sscanf(parts[4-3], "%d", &stat.PPID) return stat, nil } containerd-1.5.9/cmd/containerd-stress/exec_worker.go000066400000000000000000000064711416535272200227510ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "context" "fmt" "strings" "syscall" "time" "github.com/containerd/containerd" "github.com/containerd/containerd/cio" "github.com/containerd/containerd/oci" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" ) type execWorker struct { worker } func (w *execWorker) exec(ctx, tctx context.Context) { defer func() { w.wg.Done() logrus.Infof("worker %d finished", w.id) }() id := fmt.Sprintf("exec-container-%d", w.id) c, err := w.client.NewContainer(ctx, id, containerd.WithNewSnapshot(id, w.image), containerd.WithSnapshotter(w.snapshotter), containerd.WithNewSpec(oci.WithImageConfig(w.image), oci.WithUsername("games"), oci.WithProcessArgs("sleep", "30d")), ) if err != nil { logrus.WithError(err).Error("create exec container") return } defer c.Delete(ctx, containerd.WithSnapshotCleanup) task, err := c.NewTask(ctx, cio.NullIO) if err != nil { logrus.WithError(err).Error("create exec container's task") return } defer task.Delete(ctx, containerd.WithProcessKill) statusC, err := task.Wait(ctx) if err != nil { logrus.WithError(err).Error("wait exec container's task") return } spec, err := c.Spec(ctx) if err != nil { logrus.WithError(err).Error("failed to get spec") return } pspec := spec.Process pspec.Args = []string{"true"} for { select { case <-tctx.Done(): if err := task.Kill(ctx, syscall.SIGKILL); err != nil { logrus.WithError(err).Error("kill exec container's task") } <-statusC return default: } w.count++ id := w.getID() logrus.Debugf("starting exec %s", id) start := time.Now() if err := w.runExec(ctx, task, id, pspec); err != nil { if err != context.DeadlineExceeded || !strings.Contains(err.Error(), context.DeadlineExceeded.Error()) { w.failures++ logrus.WithError(err).Errorf("running exec %s", id) errCounter.WithValues(err.Error()).Inc() } continue } // only log times are success so we don't scew the results from failures that go really fast execTimer.WithValues(w.commit).UpdateSince(start) } } func (w *execWorker) runExec(ctx context.Context, task containerd.Task, id string, spec *specs.Process) (err error) { process, err := task.Exec(ctx, id, spec, cio.NullIO) if err != nil { return err } defer func() { if _, derr := process.Delete(ctx, containerd.WithProcessKill); err == nil { err = derr } }() statusC, err := process.Wait(ctx) if err != nil { return err } if err := process.Start(ctx); err != nil { return err } status := <-statusC _, _, err = status.Result() if err != nil { if err == context.DeadlineExceeded || err == context.Canceled { return nil } w.failures++ errCounter.WithValues(err.Error()).Inc() } return nil } containerd-1.5.9/cmd/containerd-stress/main.go000066400000000000000000000176101416535272200213550ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "context" "encoding/json" "fmt" "net/http" "os" "os/signal" "runtime" "sync" "syscall" "time" "github.com/containerd/containerd" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/plugin" metrics "github.com/docker/go-metrics" "github.com/sirupsen/logrus" "github.com/urfave/cli" ) const imageName = "docker.io/library/alpine:latest" var ( ct metrics.LabeledTimer execTimer metrics.LabeledTimer errCounter metrics.LabeledCounter binarySizeGauge metrics.LabeledGauge ) func init() { ns := metrics.NewNamespace("stress", "", nil) // if you want more fine grained metrics then you can drill down with the metrics in prom that // containerd is outputting ct = ns.NewLabeledTimer("run", "Run time of a full container during the test", "commit") execTimer = ns.NewLabeledTimer("exec", "Run time of an exec process during the test", "commit") binarySizeGauge = ns.NewLabeledGauge("binary_size", "Binary size of compiled binaries", metrics.Bytes, "name") errCounter = ns.NewLabeledCounter("errors", "Errors encountered running the stress tests", "err") metrics.Register(ns) // set higher ulimits if err := setRlimit(); err != nil { panic(err) } } type run struct { total int failures int started time.Time ended time.Time } func (r *run) start() { r.started = time.Now() } func (r *run) end() { r.ended = time.Now() } func (r *run) seconds() float64 { return r.ended.Sub(r.started).Seconds() } func (r *run) gather(workers []*worker) *result { for _, w := range workers { r.total += w.count r.failures += w.failures } sec := r.seconds() return &result{ Total: r.total, Seconds: sec, ContainersPerSecond: float64(r.total) / sec, SecondsPerContainer: sec / float64(r.total), } } type result struct { Total int `json:"total"` Failures int `json:"failures"` Seconds float64 `json:"seconds"` ContainersPerSecond float64 `json:"containersPerSecond"` SecondsPerContainer float64 `json:"secondsPerContainer"` ExecTotal int `json:"execTotal"` ExecFailures int `json:"execFailures"` } func main() { // morr power! runtime.GOMAXPROCS(runtime.NumCPU()) app := cli.NewApp() app.Name = "containerd-stress" app.Description = "stress test a containerd daemon" app.Flags = []cli.Flag{ cli.BoolFlag{ Name: "debug", Usage: "set debug output in the logs", }, cli.StringFlag{ Name: "address,a", Value: "/run/containerd/containerd.sock", Usage: "path to the containerd socket", }, cli.IntFlag{ Name: "concurrent,c", Value: 1, Usage: "set the concurrency of the stress test", }, cli.DurationFlag{ Name: "duration,d", Value: 1 * time.Minute, Usage: "set the duration of the stress test", }, cli.BoolFlag{ Name: "exec", Usage: "add execs to the stress tests", }, cli.BoolFlag{ Name: "json,j", Usage: "output results in json format", }, cli.StringFlag{ Name: "metrics,m", Usage: "address to serve the metrics API", }, cli.StringFlag{ Name: "runtime", Usage: "set the runtime to stress test", Value: plugin.RuntimeRuncV2, }, cli.StringFlag{ Name: "snapshotter", Usage: "set the snapshotter to use", Value: "overlayfs", }, } app.Before = func(context *cli.Context) error { if context.GlobalBool("json") { logrus.SetLevel(logrus.WarnLevel) } if context.GlobalBool("debug") { logrus.SetLevel(logrus.DebugLevel) } return nil } app.Commands = []cli.Command{ densityCommand, } app.Action = func(context *cli.Context) error { config := config{ Address: context.GlobalString("address"), Duration: context.GlobalDuration("duration"), Concurrency: context.GlobalInt("concurrent"), Exec: context.GlobalBool("exec"), JSON: context.GlobalBool("json"), Metrics: context.GlobalString("metrics"), Runtime: context.GlobalString("runtime"), Snapshotter: context.GlobalString("snapshotter"), } if config.Metrics != "" { return serve(config) } return test(config) } if err := app.Run(os.Args); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } type config struct { Concurrency int Duration time.Duration Address string Exec bool JSON bool Metrics string Runtime string Snapshotter string } func (c config) newClient() (*containerd.Client, error) { return containerd.New(c.Address, containerd.WithDefaultRuntime(c.Runtime)) } func serve(c config) error { go func() { if err := http.ListenAndServe(c.Metrics, metrics.Handler()); err != nil { logrus.WithError(err).Error("listen and serve") } }() checkBinarySizes() return test(c) } func test(c config) error { var ( wg sync.WaitGroup ctx = namespaces.WithNamespace(context.Background(), "stress") ) client, err := c.newClient() if err != nil { return err } defer client.Close() if err := cleanup(ctx, client); err != nil { return err } logrus.Infof("pulling %s", imageName) image, err := client.Pull(ctx, imageName, containerd.WithPullUnpack, containerd.WithPullSnapshotter(c.Snapshotter)) if err != nil { return err } tctx, cancel := context.WithTimeout(ctx, c.Duration) go func() { s := make(chan os.Signal, 1) signal.Notify(s, syscall.SIGTERM, syscall.SIGINT) <-s cancel() }() var ( workers []*worker r = &run{} ) logrus.Info("starting stress test run...") v, err := client.Version(ctx) if err != nil { return err } // create the workers along with their spec for i := 0; i < c.Concurrency; i++ { wg.Add(1) w := &worker{ id: i, wg: &wg, image: image, client: client, commit: v.Revision, snapshotter: c.Snapshotter, } workers = append(workers, w) } var exec *execWorker if c.Exec { for i := c.Concurrency; i < c.Concurrency+c.Concurrency; i++ { wg.Add(1) exec = &execWorker{ worker: worker{ id: i, wg: &wg, image: image, client: client, commit: v.Revision, snapshotter: c.Snapshotter, }, } go exec.exec(ctx, tctx) } } // start the timer and run the worker r.start() for _, w := range workers { go w.run(ctx, tctx) } // wait and end the timer wg.Wait() r.end() results := r.gather(workers) if c.Exec { results.ExecTotal = exec.count results.ExecFailures = exec.failures } logrus.Infof("ending test run in %0.3f seconds", results.Seconds) logrus.WithField("failures", r.failures).Infof( "create/start/delete %d containers in %0.3f seconds (%0.3f c/sec) or (%0.3f sec/c)", results.Total, results.Seconds, results.ContainersPerSecond, results.SecondsPerContainer, ) if c.JSON { if err := json.NewEncoder(os.Stdout).Encode(results); err != nil { return err } } return nil } // cleanup cleans up any containers in the "stress" namespace before the test run func cleanup(ctx context.Context, client *containerd.Client) error { containers, err := client.Containers(ctx) if err != nil { return err } for _, c := range containers { task, err := c.Task(ctx, nil) if err == nil { task.Delete(ctx, containerd.WithProcessKill) } if err := c.Delete(ctx, containerd.WithSnapshotCleanup); err != nil { if derr := c.Delete(ctx); derr == nil { continue } return err } } return nil } containerd-1.5.9/cmd/containerd-stress/rlimit_freebsd.go000066400000000000000000000017541416535272200234250ustar00rootroot00000000000000// +build freebsd /* Copyright The containerd 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 main import ( "syscall" ) func setRlimit() error { rlimit := int64(100000) if rlimit > 0 { var limit syscall.Rlimit if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { return err } if limit.Cur < rlimit { limit.Cur = rlimit if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { return err } } } return nil } containerd-1.5.9/cmd/containerd-stress/rlimit_unix.go000066400000000000000000000020641416535272200227710ustar00rootroot00000000000000// +build !windows,!freebsd /* Copyright The containerd 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 main import ( "syscall" ) func setRlimit() error { rlimit := uint64(100000) if rlimit > 0 { var limit syscall.Rlimit if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { return err } if limit.Cur < rlimit { limit.Cur = rlimit if limit.Max < limit.Cur { limit.Max = limit.Cur } if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { return err } } } return nil } containerd-1.5.9/cmd/containerd-stress/rlimit_windows.go000066400000000000000000000012341416535272200234760ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 main func setRlimit() error { return nil } containerd-1.5.9/cmd/containerd-stress/size.go000066400000000000000000000022251416535272200213770ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "os" "path/filepath" "github.com/sirupsen/logrus" ) var binaries = []string{ "ctr", "containerd", "containerd-shim", "containerd-shim-runc-v1", "containerd-shim-runc-v2", } // checkBinarySizes checks and reports the binary sizes for the containerd compiled binaries to prometheus func checkBinarySizes() { for _, name := range binaries { fi, err := os.Stat(filepath.Join("/usr/local/bin", name)) if err != nil { logrus.WithError(err).Error("stat binary") continue } binarySizeGauge.WithValues(name).Set(float64(fi.Size())) } } containerd-1.5.9/cmd/containerd-stress/worker.go000066400000000000000000000055011416535272200217360ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "context" "fmt" "strings" "sync" "time" "github.com/containerd/containerd" "github.com/containerd/containerd/cio" "github.com/containerd/containerd/oci" "github.com/sirupsen/logrus" ) type worker struct { id int wg *sync.WaitGroup count int failures int client *containerd.Client image containerd.Image commit string snapshotter string } func (w *worker) run(ctx, tctx context.Context) { defer func() { w.wg.Done() logrus.Infof("worker %d finished", w.id) }() for { select { case <-tctx.Done(): return default: } w.count++ id := w.getID() logrus.Debugf("starting container %s", id) start := time.Now() if err := w.runContainer(ctx, id); err != nil { if err != context.DeadlineExceeded || !strings.Contains(err.Error(), context.DeadlineExceeded.Error()) { w.failures++ logrus.WithError(err).Errorf("running container %s", id) errCounter.WithValues(err.Error()).Inc() } continue } // only log times are success so we don't scew the results from failures that go really fast ct.WithValues(w.commit).UpdateSince(start) } } func (w *worker) runContainer(ctx context.Context, id string) (err error) { // fix up cgroups path for a default config c, err := w.client.NewContainer(ctx, id, containerd.WithSnapshotter(w.snapshotter), containerd.WithNewSnapshot(id, w.image), containerd.WithNewSpec(oci.WithImageConfig(w.image), oci.WithUsername("games"), oci.WithProcessArgs("true")), ) if err != nil { return err } defer func() { if derr := c.Delete(ctx, containerd.WithSnapshotCleanup); err == nil { err = derr } }() task, err := c.NewTask(ctx, cio.NullIO) if err != nil { return err } defer func() { if _, derr := task.Delete(ctx, containerd.WithProcessKill); err == nil { err = derr } }() statusC, err := task.Wait(ctx) if err != nil { return err } if err := task.Start(ctx); err != nil { return err } status := <-statusC _, _, err = status.Result() if err != nil { if err == context.DeadlineExceeded || err == context.Canceled { return nil } w.failures++ errCounter.WithValues(err.Error()).Inc() } return nil } func (w *worker) getID() string { return fmt.Sprintf("%d-%d", w.id, w.count) } containerd-1.5.9/cmd/containerd/000077500000000000000000000000001416535272200165545ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd/builtins.go000066400000000000000000000030161416535272200207340ustar00rootroot00000000000000/* Copyright The containerd 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 main // register containerd builtins here import ( _ "github.com/containerd/containerd/diff/walking/plugin" _ "github.com/containerd/containerd/gc/scheduler" _ "github.com/containerd/containerd/runtime/restart/monitor" _ "github.com/containerd/containerd/services/containers" _ "github.com/containerd/containerd/services/content" _ "github.com/containerd/containerd/services/diff" _ "github.com/containerd/containerd/services/events" _ "github.com/containerd/containerd/services/healthcheck" _ "github.com/containerd/containerd/services/images" _ "github.com/containerd/containerd/services/introspection" _ "github.com/containerd/containerd/services/leases" _ "github.com/containerd/containerd/services/namespaces" _ "github.com/containerd/containerd/services/opt" _ "github.com/containerd/containerd/services/snapshots" _ "github.com/containerd/containerd/services/tasks" _ "github.com/containerd/containerd/services/version" ) containerd-1.5.9/cmd/containerd/builtins_aufs_linux.go000066400000000000000000000012431416535272200231710ustar00rootroot00000000000000// +build !no_aufs /* Copyright The containerd 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 main import _ "github.com/containerd/aufs/plugin" containerd-1.5.9/cmd/containerd/builtins_btrfs_linux.go000066400000000000000000000012761416535272200233610ustar00rootroot00000000000000// +build !no_btrfs,cgo /* Copyright The containerd 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 main import _ "github.com/containerd/containerd/snapshots/btrfs/plugin" containerd-1.5.9/cmd/containerd/builtins_cri.go000066400000000000000000000012771416535272200216000ustar00rootroot00000000000000// +build linux,!no_cri windows,!no_cri /* Copyright The containerd 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 main import _ "github.com/containerd/containerd/pkg/cri" containerd-1.5.9/cmd/containerd/builtins_devmapper_linux.go000066400000000000000000000013021416535272200242120ustar00rootroot00000000000000// +build !no_devmapper /* Copyright The containerd 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 main import _ "github.com/containerd/containerd/snapshots/devmapper/plugin" containerd-1.5.9/cmd/containerd/builtins_freebsd.go000066400000000000000000000012161416535272200224260ustar00rootroot00000000000000/* Copyright The containerd 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 main import _ "github.com/containerd/zfs/plugin" containerd-1.5.9/cmd/containerd/builtins_linux.go000066400000000000000000000017771416535272200221670ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( _ "github.com/containerd/containerd/metrics/cgroups" _ "github.com/containerd/containerd/metrics/cgroups/v2" _ "github.com/containerd/containerd/runtime/v1/linux" _ "github.com/containerd/containerd/runtime/v2" _ "github.com/containerd/containerd/runtime/v2/runc/options" _ "github.com/containerd/containerd/snapshots/native/plugin" _ "github.com/containerd/containerd/snapshots/overlay/plugin" ) containerd-1.5.9/cmd/containerd/builtins_unix.go000066400000000000000000000013151416535272200217770ustar00rootroot00000000000000// +build darwin freebsd solaris /* Copyright The containerd 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 main import ( _ "github.com/containerd/containerd/snapshots/native/plugin" ) containerd-1.5.9/cmd/containerd/builtins_windows.go000066400000000000000000000016011416535272200225040ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 main import ( _ "github.com/containerd/containerd/diff/lcow" _ "github.com/containerd/containerd/diff/windows" _ "github.com/containerd/containerd/runtime/v2" _ "github.com/containerd/containerd/snapshots/lcow" _ "github.com/containerd/containerd/snapshots/windows" ) containerd-1.5.9/cmd/containerd/builtins_zfs_linux.go000066400000000000000000000012411416535272200230330ustar00rootroot00000000000000// +build !no_zfs /* Copyright The containerd 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 main import _ "github.com/containerd/zfs/plugin" containerd-1.5.9/cmd/containerd/command/000077500000000000000000000000001416535272200201725ustar00rootroot00000000000000containerd-1.5.9/cmd/containerd/command/config.go000066400000000000000000000114631416535272200217730ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( gocontext "context" "io" "os" "path/filepath" "github.com/containerd/containerd/defaults" "github.com/containerd/containerd/images" "github.com/containerd/containerd/pkg/timeout" "github.com/containerd/containerd/services/server" srvconfig "github.com/containerd/containerd/services/server/config" ocispec "github.com/opencontainers/image-spec/specs-go/v1" "github.com/pelletier/go-toml" "github.com/urfave/cli" ) // Config is a wrapper of server config for printing out. type Config struct { *srvconfig.Config // Plugins overrides `Plugins map[string]toml.Tree` in server config. Plugins map[string]interface{} `toml:"plugins"` } // WriteTo marshals the config to the provided writer func (c *Config) WriteTo(w io.Writer) (int64, error) { return 0, toml.NewEncoder(w).Encode(c) } func outputConfig(cfg *srvconfig.Config) error { config := &Config{ Config: cfg, } plugins, err := server.LoadPlugins(gocontext.Background(), config.Config) if err != nil { return err } if len(plugins) != 0 { config.Plugins = make(map[string]interface{}) for _, p := range plugins { if p.Config == nil { continue } pc, err := config.Decode(p) if err != nil { return err } config.Plugins[p.URI()] = pc } } if config.Timeouts == nil { config.Timeouts = make(map[string]string) } timeouts := timeout.All() for k, v := range timeouts { if config.Timeouts[k] == "" { config.Timeouts[k] = v.String() } } // for the time being, keep the defaultConfig's version set at 1 so that // when a config without a version is loaded from disk and has no version // set, we assume it's a v1 config. But when generating new configs via // this command, generate the v2 config config.Config.Version = 2 // remove overridden Plugins type to avoid duplication in output config.Config.Plugins = nil _, err = config.WriteTo(os.Stdout) return err } var configCommand = cli.Command{ Name: "config", Usage: "information on the containerd config", Subcommands: []cli.Command{ { Name: "default", Usage: "see the output of the default config", Action: func(context *cli.Context) error { return outputConfig(defaultConfig()) }, }, { Name: "dump", Usage: "see the output of the final main config with imported in subconfig files", Action: func(context *cli.Context) error { config := defaultConfig() if err := srvconfig.LoadConfig(context.GlobalString("config"), config); err != nil && !os.IsNotExist(err) { return err } return outputConfig(config) }, }, }, } func platformAgnosticDefaultConfig() *srvconfig.Config { return &srvconfig.Config{ // see: https://github.com/containerd/containerd/blob/5c6ea7fdc1247939edaddb1eba62a94527418687/RELEASES.md#daemon-configuration // this version MUST remain set to 1 until either there exists a means to // override / configure the default at the containerd cli .. or when // version 1 is no longer supported Version: 1, Root: defaults.DefaultRootDir, State: defaults.DefaultStateDir, GRPC: srvconfig.GRPCConfig{ Address: defaults.DefaultAddress, MaxRecvMsgSize: defaults.DefaultMaxRecvMsgSize, MaxSendMsgSize: defaults.DefaultMaxSendMsgSize, }, DisabledPlugins: []string{}, RequiredPlugins: []string{}, StreamProcessors: streamProcessors(), } } func streamProcessors() map[string]srvconfig.StreamProcessor { const ( ctdDecoder = "ctd-decoder" basename = "io.containerd.ocicrypt.decoder.v1" ) decryptionKeysPath := filepath.Join(defaults.DefaultConfigDir, "ocicrypt", "keys") ctdDecoderArgs := []string{ "--decryption-keys-path", decryptionKeysPath, } ctdDecoderEnv := []string{ "OCICRYPT_KEYPROVIDER_CONFIG=" + filepath.Join(defaults.DefaultConfigDir, "ocicrypt", "ocicrypt_keyprovider.conf"), } return map[string]srvconfig.StreamProcessor{ basename + ".tar.gzip": { Accepts: []string{images.MediaTypeImageLayerGzipEncrypted}, Returns: ocispec.MediaTypeImageLayerGzip, Path: ctdDecoder, Args: ctdDecoderArgs, Env: ctdDecoderEnv, }, basename + ".tar": { Accepts: []string{images.MediaTypeImageLayerEncrypted}, Returns: ocispec.MediaTypeImageLayer, Path: ctdDecoder, Args: ctdDecoderArgs, Env: ctdDecoderEnv, }, } } containerd-1.5.9/cmd/containerd/command/config_linux.go000066400000000000000000000014111416535272200232020ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( srvconfig "github.com/containerd/containerd/services/server/config" ) func defaultConfig() *srvconfig.Config { return platformAgnosticDefaultConfig() } containerd-1.5.9/cmd/containerd/command/config_unsupported.go000066400000000000000000000017031416535272200244370ustar00rootroot00000000000000// +build !linux,!windows,!solaris /* Copyright The containerd 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 command import ( "github.com/containerd/containerd/defaults" srvconfig "github.com/containerd/containerd/services/server/config" ) func defaultConfig() *srvconfig.Config { cfg := platformAgnosticDefaultConfig() cfg.Debug = srvconfig.Debug{ Level: "info", Address: defaults.DefaultDebugAddress, } return cfg } containerd-1.5.9/cmd/containerd/command/config_windows.go000066400000000000000000000014111416535272200235350ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( srvconfig "github.com/containerd/containerd/services/server/config" ) func defaultConfig() *srvconfig.Config { return platformAgnosticDefaultConfig() } containerd-1.5.9/cmd/containerd/command/main.go000066400000000000000000000231521416535272200214500ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( gocontext "context" "fmt" "io/ioutil" "net" "os" "os/signal" "path/filepath" "runtime" "time" "github.com/containerd/containerd/defaults" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/log" "github.com/containerd/containerd/mount" "github.com/containerd/containerd/services/server" srvconfig "github.com/containerd/containerd/services/server/config" "github.com/containerd/containerd/sys" "github.com/containerd/containerd/version" "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/urfave/cli" "google.golang.org/grpc/grpclog" ) const usage = ` __ _ __ _________ ____ / /_____ _(_)___ ___ _________/ / / ___/ __ \/ __ \/ __/ __ ` + "`" + `/ / __ \/ _ \/ ___/ __ / / /__/ /_/ / / / / /_/ /_/ / / / / / __/ / / /_/ / \___/\____/_/ /_/\__/\__,_/_/_/ /_/\___/_/ \__,_/ high performance container runtime ` func init() { // Discard grpc logs so that they don't mess with our stdio grpclog.SetLoggerV2(grpclog.NewLoggerV2(ioutil.Discard, ioutil.Discard, ioutil.Discard)) cli.VersionPrinter = func(c *cli.Context) { fmt.Println(c.App.Name, version.Package, c.App.Version, version.Revision) } } // App returns a *cli.App instance. func App() *cli.App { app := cli.NewApp() app.Name = "containerd" app.Version = version.Version app.Usage = usage app.Description = ` containerd is a high performance container runtime whose daemon can be started by using this command. If none of the *config*, *publish*, or *help* commands are specified, the default action of the **containerd** command is to start the containerd daemon in the foreground. A default configuration is used if no TOML configuration is specified or located at the default file location. The *containerd config* command can be used to generate the default configuration for containerd. The output of that command can be used and modified as necessary as a custom configuration.` app.Flags = []cli.Flag{ cli.StringFlag{ Name: "config,c", Usage: "path to the configuration file", Value: filepath.Join(defaults.DefaultConfigDir, "config.toml"), }, cli.StringFlag{ Name: "log-level,l", Usage: "set the logging level [trace, debug, info, warn, error, fatal, panic]", }, cli.StringFlag{ Name: "address,a", Usage: "address for containerd's GRPC server", }, cli.StringFlag{ Name: "root", Usage: "containerd root directory", }, cli.StringFlag{ Name: "state", Usage: "containerd state directory", }, } app.Flags = append(app.Flags, serviceFlags()...) app.Commands = []cli.Command{ configCommand, publishCommand, ociHook, } app.Action = func(context *cli.Context) error { var ( start = time.Now() signals = make(chan os.Signal, 2048) serverC = make(chan *server.Server, 1) ctx = gocontext.Background() config = defaultConfig() ) // Only try to load the config if it either exists, or the user explicitly // told us to load this path. configPath := context.GlobalString("config") _, err := os.Stat(configPath) if !os.IsNotExist(err) || context.GlobalIsSet("config") { if err := srvconfig.LoadConfig(configPath, config); err != nil { return err } } // Apply flags to the config if err := applyFlags(context, config); err != nil { return err } // Make sure top-level directories are created early. if err := server.CreateTopLevelDirectories(config); err != nil { return err } // Stop if we are registering or unregistering against Windows SCM. stop, err := registerUnregisterService(config.Root) if err != nil { logrus.Fatal(err) } if stop { return nil } done := handleSignals(ctx, signals, serverC) // start the signal handler as soon as we can to make sure that // we don't miss any signals during boot signal.Notify(signals, handledSignals...) // cleanup temp mounts if err := mount.SetTempMountLocation(filepath.Join(config.Root, "tmpmounts")); err != nil { return errors.Wrap(err, "creating temp mount location") } // unmount all temp mounts on boot for the server warnings, err := mount.CleanupTempMounts(0) if err != nil { log.G(ctx).WithError(err).Error("unmounting temp mounts") } for _, w := range warnings { log.G(ctx).WithError(w).Warn("cleanup temp mount") } if config.GRPC.Address == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "grpc address cannot be empty") } if config.TTRPC.Address == "" { // If TTRPC was not explicitly configured, use defaults based on GRPC. config.TTRPC.Address = fmt.Sprintf("%s.ttrpc", config.GRPC.Address) config.TTRPC.UID = config.GRPC.UID config.TTRPC.GID = config.GRPC.GID } log.G(ctx).WithFields(logrus.Fields{ "version": version.Version, "revision": version.Revision, }).Info("starting containerd") server, err := server.New(ctx, config) if err != nil { return err } // Launch as a Windows Service if necessary if err := launchService(server, done); err != nil { logrus.Fatal(err) } serverC <- server if config.Debug.Address != "" { var l net.Listener if isLocalAddress(config.Debug.Address) { if l, err = sys.GetLocalListener(config.Debug.Address, config.Debug.UID, config.Debug.GID); err != nil { return errors.Wrapf(err, "failed to get listener for debug endpoint") } } else { if l, err = net.Listen("tcp", config.Debug.Address); err != nil { return errors.Wrapf(err, "failed to get listener for debug endpoint") } } serve(ctx, l, server.ServeDebug) } if config.Metrics.Address != "" { l, err := net.Listen("tcp", config.Metrics.Address) if err != nil { return errors.Wrapf(err, "failed to get listener for metrics endpoint") } serve(ctx, l, server.ServeMetrics) } // setup the ttrpc endpoint tl, err := sys.GetLocalListener(config.TTRPC.Address, config.TTRPC.UID, config.TTRPC.GID) if err != nil { return errors.Wrapf(err, "failed to get listener for main ttrpc endpoint") } serve(ctx, tl, server.ServeTTRPC) if config.GRPC.TCPAddress != "" { l, err := net.Listen("tcp", config.GRPC.TCPAddress) if err != nil { return errors.Wrapf(err, "failed to get listener for TCP grpc endpoint") } serve(ctx, l, server.ServeTCP) } // setup the main grpc endpoint l, err := sys.GetLocalListener(config.GRPC.Address, config.GRPC.UID, config.GRPC.GID) if err != nil { return errors.Wrapf(err, "failed to get listener for main endpoint") } serve(ctx, l, server.ServeGRPC) if err := notifyReady(ctx); err != nil { log.G(ctx).WithError(err).Warn("notify ready failed") } log.G(ctx).Infof("containerd successfully booted in %fs", time.Since(start).Seconds()) <-done return nil } return app } func serve(ctx gocontext.Context, l net.Listener, serveFunc func(net.Listener) error) { path := l.Addr().String() log.G(ctx).WithField("address", path).Info("serving...") go func() { defer l.Close() if err := serveFunc(l); err != nil { log.G(ctx).WithError(err).WithField("address", path).Fatal("serve failure") } }() } func applyFlags(context *cli.Context, config *srvconfig.Config) error { // the order for config vs flag values is that flags will always override // the config values if they are set if err := setLogLevel(context, config); err != nil { return err } if err := setLogFormat(config); err != nil { return err } for _, v := range []struct { name string d *string }{ { name: "root", d: &config.Root, }, { name: "state", d: &config.State, }, { name: "address", d: &config.GRPC.Address, }, } { if s := context.GlobalString(v.name); s != "" { *v.d = s } } applyPlatformFlags(context) return nil } func setLogLevel(context *cli.Context, config *srvconfig.Config) error { l := context.GlobalString("log-level") if l == "" { l = config.Debug.Level } if l != "" { lvl, err := logrus.ParseLevel(l) if err != nil { return err } logrus.SetLevel(lvl) } return nil } func setLogFormat(config *srvconfig.Config) error { f := config.Debug.Format if f == "" { f = log.TextFormat } switch f { case log.TextFormat: logrus.SetFormatter(&logrus.TextFormatter{ TimestampFormat: log.RFC3339NanoFixed, FullTimestamp: true, }) case log.JSONFormat: logrus.SetFormatter(&logrus.JSONFormatter{ TimestampFormat: log.RFC3339NanoFixed, }) default: return errors.Errorf("unknown log format: %s", f) } return nil } func dumpStacks(writeToFile bool) { var ( buf []byte stackSize int ) bufferLen := 16384 for stackSize == len(buf) { buf = make([]byte, bufferLen) stackSize = runtime.Stack(buf, true) bufferLen *= 2 } buf = buf[:stackSize] logrus.Infof("=== BEGIN goroutine stack dump ===\n%s\n=== END goroutine stack dump ===", buf) if writeToFile { // Also write to file to aid gathering diagnostics name := filepath.Join(os.TempDir(), fmt.Sprintf("containerd.%d.stacks.log", os.Getpid())) f, err := os.Create(name) if err != nil { return } defer f.Close() f.WriteString(string(buf)) logrus.Infof("goroutine stack dump written to %s", name) } } containerd-1.5.9/cmd/containerd/command/main_unix.go000066400000000000000000000034461416535272200225170ustar00rootroot00000000000000// +build linux darwin freebsd solaris /* Copyright The containerd 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 command import ( "context" "os" "path/filepath" "github.com/containerd/containerd/log" "github.com/containerd/containerd/services/server" "golang.org/x/sys/unix" ) var handledSignals = []os.Signal{ unix.SIGTERM, unix.SIGINT, unix.SIGUSR1, unix.SIGPIPE, } func handleSignals(ctx context.Context, signals chan os.Signal, serverC chan *server.Server) chan struct{} { done := make(chan struct{}, 1) go func() { var server *server.Server for { select { case s := <-serverC: server = s case s := <-signals: // Do not print message when deailing with SIGPIPE, which may cause // nested signals and consume lots of cpu bandwidth. if s == unix.SIGPIPE { continue } log.G(ctx).WithField("signal", s).Debug("received signal") switch s { case unix.SIGUSR1: dumpStacks(true) default: if err := notifyStopping(ctx); err != nil { log.G(ctx).WithError(err).Error("notify stopping failed") } if server == nil { close(done) return } server.Stop() close(done) return } } } }() return done } func isLocalAddress(path string) bool { return filepath.IsAbs(path) } containerd-1.5.9/cmd/containerd/command/main_windows.go000066400000000000000000000065301416535272200232230ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( "context" "fmt" "os" "strings" "unsafe" "github.com/Microsoft/go-winio/pkg/etw" "github.com/Microsoft/go-winio/pkg/etwlogrus" "github.com/Microsoft/go-winio/pkg/guid" "github.com/containerd/containerd/log" "github.com/containerd/containerd/services/server" "github.com/sirupsen/logrus" "golang.org/x/sys/windows" ) var ( handledSignals = []os.Signal{ windows.SIGTERM, windows.SIGINT, } ) func handleSignals(ctx context.Context, signals chan os.Signal, serverC chan *server.Server) chan struct{} { done := make(chan struct{}) go func() { var server *server.Server for { select { case s := <-serverC: server = s case s := <-signals: log.G(ctx).WithField("signal", s).Debug("received signal") if err := notifyStopping(ctx); err != nil { log.G(ctx).WithError(err).Error("notify stopping failed") } if server == nil { close(done) return } server.Stop() close(done) } } }() setupDumpStacks() return done } func setupDumpStacks() { // Windows does not support signals like *nix systems. So instead of // trapping on SIGUSR1 to dump stacks, we wait on a Win32 event to be // signaled. ACL'd to builtin administrators and local system event := "Global\\stackdump-" + fmt.Sprint(os.Getpid()) ev, _ := windows.UTF16PtrFromString(event) sd, err := windows.SecurityDescriptorFromString("D:P(A;;GA;;;BA)(A;;GA;;;SY)") if err != nil { logrus.Errorf("failed to get security descriptor for debug stackdump event %s: %s", event, err.Error()) return } var sa windows.SecurityAttributes sa.Length = uint32(unsafe.Sizeof(sa)) sa.InheritHandle = 1 sa.SecurityDescriptor = sd h, err := windows.CreateEvent(&sa, 0, 0, ev) if h == 0 || err != nil { logrus.Errorf("failed to create debug stackdump event %s: %s", event, err.Error()) return } go func() { logrus.Debugf("Stackdump - waiting signal at %s", event) for { windows.WaitForSingleObject(h, windows.INFINITE) dumpStacks(true) } }() } func etwCallback(sourceID guid.GUID, state etw.ProviderState, level etw.Level, matchAnyKeyword uint64, matchAllKeyword uint64, filterData uintptr) { if state == etw.ProviderStateCaptureState { dumpStacks(false) } } func init() { // Provider ID: 2acb92c0-eb9b-571a-69cf-8f3410f383ad // Provider and hook aren't closed explicitly, as they will exist until // process exit. GUID is generated based on name - see // Microsoft/go-winio/tools/etw-provider-gen. provider, err := etw.NewProvider("ContainerD", etwCallback) if err != nil { logrus.Error(err) } else { if hook, err := etwlogrus.NewHookFromProvider(provider); err == nil { logrus.AddHook(hook) } else { logrus.Error(err) } } } func isLocalAddress(path string) bool { return strings.HasPrefix(path, `\\.\pipe\`) } containerd-1.5.9/cmd/containerd/command/notify_linux.go000066400000000000000000000024371416535272200232560ustar00rootroot00000000000000// +build linux /* Copyright The containerd 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 command import ( "context" sd "github.com/coreos/go-systemd/v22/daemon" "github.com/containerd/containerd/log" ) // notifyReady notifies systemd that the daemon is ready to serve requests func notifyReady(ctx context.Context) error { return sdNotify(ctx, sd.SdNotifyReady) } // notifyStopping notifies systemd that the daemon is about to be stopped func notifyStopping(ctx context.Context) error { return sdNotify(ctx, sd.SdNotifyStopping) } func sdNotify(ctx context.Context, state string) error { notified, err := sd.SdNotify(false, state) log.G(ctx). WithError(err). WithField("notified", notified). WithField("state", state). Debug("sd notification") return err } containerd-1.5.9/cmd/containerd/command/notify_unsupported.go000066400000000000000000000014121416535272200244770ustar00rootroot00000000000000// +build !linux /* Copyright The containerd 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 command import ( "context" ) func notifyReady(ctx context.Context) error { return nil } func notifyStopping(ctx context.Context) error { return nil } containerd-1.5.9/cmd/containerd/command/oci-hook.go000066400000000000000000000066041416535272200222370ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( "bytes" "encoding/json" "io" "os" "path/filepath" "syscall" "text/template" specs "github.com/opencontainers/runtime-spec/specs-go" "github.com/urfave/cli" ) var ociHook = cli.Command{ Name: "oci-hook", Usage: "provides a base for OCI runtime hooks to allow arguments to be injected.", Action: func(context *cli.Context) error { state, err := loadHookState(os.Stdin) if err != nil { return err } spec, err := loadSpec(state.Bundle) if err != nil { return err } var ( ctx = newTemplateContext(state, spec) args = []string(context.Args()) env = os.Environ() ) if err := newList(&args).render(ctx); err != nil { return err } if err := newList(&env).render(ctx); err != nil { return err } return syscall.Exec(args[0], args, env) }, } type hookSpec struct { Root struct { Path string `json:"path"` } `json:"root"` } func loadSpec(bundle string) (*hookSpec, error) { f, err := os.Open(filepath.Join(bundle, "config.json")) if err != nil { return nil, err } defer f.Close() var s hookSpec if err := json.NewDecoder(f).Decode(&s); err != nil { return nil, err } return &s, nil } func loadHookState(r io.Reader) (*specs.State, error) { var s specs.State if err := json.NewDecoder(r).Decode(&s); err != nil { return nil, err } return &s, nil } func newTemplateContext(state *specs.State, spec *hookSpec) *templateContext { t := &templateContext{ state: state, root: spec.Root.Path, } t.funcs = template.FuncMap{ "id": t.id, "bundle": t.bundle, "rootfs": t.rootfs, "pid": t.pid, "annotation": t.annotation, "status": t.status, } return t } type templateContext struct { state *specs.State root string funcs template.FuncMap } func (t *templateContext) id() string { return t.state.ID } func (t *templateContext) bundle() string { return t.state.Bundle } func (t *templateContext) rootfs() string { if filepath.IsAbs(t.root) { return t.root } return filepath.Join(t.state.Bundle, t.root) } func (t *templateContext) pid() int { return t.state.Pid } func (t *templateContext) annotation(k string) string { return t.state.Annotations[k] } func (t *templateContext) status() string { return string(t.state.Status) } func render(ctx *templateContext, source string, out io.Writer) error { t, err := template.New("oci-hook").Funcs(ctx.funcs).Parse(source) if err != nil { return err } return t.Execute(out, ctx) } func newList(l *[]string) *templateList { return &templateList{ l: l, } } type templateList struct { l *[]string } func (l *templateList) render(ctx *templateContext) error { buf := bytes.NewBuffer(nil) for i, s := range *l.l { buf.Reset() if err := render(ctx, s, buf); err != nil { return err } (*l.l)[i] = buf.String() } buf.Reset() return nil } containerd-1.5.9/cmd/containerd/command/publish.go000066400000000000000000000061021416535272200221660ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( gocontext "context" "io" "io/ioutil" "net" "os" "time" eventsapi "github.com/containerd/containerd/api/services/events/v1" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/pkg/dialer" "github.com/gogo/protobuf/types" "github.com/pkg/errors" "github.com/urfave/cli" "google.golang.org/grpc" "google.golang.org/grpc/backoff" ) var publishCommand = cli.Command{ Name: "publish", Usage: "binary to publish events to containerd", Flags: []cli.Flag{ cli.StringFlag{ Name: "namespace", Usage: "namespace to publish to", }, cli.StringFlag{ Name: "topic", Usage: "topic of the event", }, }, Action: func(context *cli.Context) error { ctx := namespaces.WithNamespace(gocontext.Background(), context.String("namespace")) topic := context.String("topic") if topic == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "topic required to publish event") } payload, err := getEventPayload(os.Stdin) if err != nil { return err } client, err := connectEvents(context.GlobalString("address")) if err != nil { return err } if _, err := client.Publish(ctx, &eventsapi.PublishRequest{ Topic: topic, Event: payload, }); err != nil { return errdefs.FromGRPC(err) } return nil }, } func getEventPayload(r io.Reader) (*types.Any, error) { data, err := ioutil.ReadAll(r) if err != nil { return nil, err } var any types.Any if err := any.Unmarshal(data); err != nil { return nil, err } return &any, nil } func connectEvents(address string) (eventsapi.EventsClient, error) { conn, err := connect(address, dialer.ContextDialer) if err != nil { return nil, errors.Wrapf(err, "failed to dial %q", address) } return eventsapi.NewEventsClient(conn), nil } func connect(address string, d func(gocontext.Context, string) (net.Conn, error)) (*grpc.ClientConn, error) { backoffConfig := backoff.DefaultConfig backoffConfig.MaxDelay = 3 * time.Second connParams := grpc.ConnectParams{ Backoff: backoffConfig, } gopts := []grpc.DialOption{ grpc.WithBlock(), grpc.WithInsecure(), grpc.WithContextDialer(d), grpc.FailOnNonTempDialError(true), grpc.WithConnectParams(connParams), } ctx, cancel := gocontext.WithTimeout(gocontext.Background(), 2*time.Second) defer cancel() conn, err := grpc.DialContext(ctx, dialer.DialAddress(address), gopts...) if err != nil { return nil, errors.Wrapf(err, "failed to dial %q", address) } return conn, nil } containerd-1.5.9/cmd/containerd/command/service_unsupported.go000066400000000000000000000023541416535272200246350ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 command import ( "github.com/containerd/containerd/services/server" "github.com/urfave/cli" ) // serviceFlags returns an array of flags for configuring containerd to run // as a service. Only relevant on Windows. func serviceFlags() []cli.Flag { return nil } // applyPlatformFlags applies platform-specific flags. func applyPlatformFlags(context *cli.Context) { } // registerUnregisterService is only relevant on Windows. func registerUnregisterService(root string) (bool, error) { return false, nil } // launchService is only relevant on Windows. func launchService(s *server.Server, done chan struct{}) error { return nil } containerd-1.5.9/cmd/containerd/command/service_windows.go000066400000000000000000000222331416535272200237350ustar00rootroot00000000000000/* Copyright The containerd 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 command import ( "fmt" "io/ioutil" "log" "os" "os/exec" "path/filepath" "time" "unsafe" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/services/server" "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/urfave/cli" "golang.org/x/sys/windows" "golang.org/x/sys/windows/svc" "golang.org/x/sys/windows/svc/debug" "golang.org/x/sys/windows/svc/mgr" ) var ( serviceNameFlag string registerServiceFlag bool unregisterServiceFlag bool runServiceFlag bool logFileFlag string kernel32 = windows.NewLazySystemDLL("kernel32.dll") setStdHandle = kernel32.NewProc("SetStdHandle") allocConsole = kernel32.NewProc("AllocConsole") oldStderr windows.Handle panicFile *os.File ) const defaultServiceName = "containerd" // serviceFlags returns an array of flags for configuring containerd to run // as a Windows service under control of SCM. func serviceFlags() []cli.Flag { return []cli.Flag{ cli.StringFlag{ Name: "service-name", Usage: "Set the Windows service name", Value: defaultServiceName, }, cli.BoolFlag{ Name: "register-service", Usage: "Register the service and exit", }, cli.BoolFlag{ Name: "unregister-service", Usage: "Unregister the service and exit", }, cli.BoolFlag{ Name: "run-service", Usage: "", Hidden: true, }, cli.StringFlag{ Name: "log-file", Usage: "Path to the containerd log file", }, } } // applyPlatformFlags applies platform-specific flags. func applyPlatformFlags(context *cli.Context) { serviceNameFlag = context.GlobalString("service-name") if serviceNameFlag == "" { serviceNameFlag = defaultServiceName } for _, v := range []struct { name string d *bool }{ { name: "register-service", d: ®isterServiceFlag, }, { name: "unregister-service", d: &unregisterServiceFlag, }, { name: "run-service", d: &runServiceFlag, }, } { *v.d = context.GlobalBool(v.name) } logFileFlag = context.GlobalString("log-file") } type handler struct { fromsvc chan error s *server.Server done chan struct{} // Indicates back to app main to quit } func getServicePath() (string, error) { p, err := exec.LookPath(os.Args[0]) if err != nil { return "", err } return filepath.Abs(p) } func registerService() error { p, err := getServicePath() if err != nil { return err } m, err := mgr.Connect() if err != nil { return err } defer m.Disconnect() c := mgr.Config{ ServiceType: windows.SERVICE_WIN32_OWN_PROCESS, StartType: mgr.StartAutomatic, ErrorControl: mgr.ErrorNormal, DisplayName: "Containerd", Description: "Container runtime", } // Configure the service to launch with the arguments that were just passed. args := []string{"--run-service"} for _, a := range os.Args[1:] { if a != "--register-service" && a != "--unregister-service" { args = append(args, a) } } s, err := m.CreateService(serviceNameFlag, p, c, args...) if err != nil { return err } defer s.Close() // See http://stackoverflow.com/questions/35151052/how-do-i-configure-failure-actions-of-a-windows-service-written-in-go const ( scActionNone = 0 scActionRestart = 1 serviceConfigFailureActions = 2 ) type serviceFailureActions struct { ResetPeriod uint32 RebootMsg *uint16 Command *uint16 ActionsCount uint32 Actions uintptr } type scAction struct { Type uint32 Delay uint32 } t := []scAction{ {Type: scActionRestart, Delay: uint32(15 * time.Second / time.Millisecond)}, {Type: scActionRestart, Delay: uint32(15 * time.Second / time.Millisecond)}, {Type: scActionNone}, } lpInfo := serviceFailureActions{ResetPeriod: uint32(24 * time.Hour / time.Second), ActionsCount: uint32(3), Actions: uintptr(unsafe.Pointer(&t[0]))} err = windows.ChangeServiceConfig2(s.Handle, serviceConfigFailureActions, (*byte)(unsafe.Pointer(&lpInfo))) if err != nil { return err } return nil } func unregisterService() error { m, err := mgr.Connect() if err != nil { return err } defer m.Disconnect() s, err := m.OpenService(serviceNameFlag) if err != nil { return err } defer s.Close() err = s.Delete() if err != nil { return err } return nil } // registerUnregisterService is an entrypoint early in the daemon startup // to handle (un-)registering against Windows Service Control Manager (SCM). // It returns an indication to stop on successful SCM operation, and an error. func registerUnregisterService(root string) (bool, error) { if unregisterServiceFlag { if registerServiceFlag { return true, errors.Wrap(errdefs.ErrInvalidArgument, "--register-service and --unregister-service cannot be used together") } return true, unregisterService() } if registerServiceFlag { return true, registerService() } if runServiceFlag { // Allocate a conhost for containerd here. We don't actually use this // at all in containerd, but it will be inherited by any processes // containerd executes, so they won't need to allocate their own // conhosts. This is important for two reasons: // - Creating a conhost slows down process launch. // - We have seen reliability issues when launching many processes. // Sometimes the process invocation will fail due to an error when // creating the conhost. // // This needs to be done before initializing the panic file, as // AllocConsole sets the stdio handles to point to the new conhost, // and we want to make sure stderr goes to the panic file. r, _, err := allocConsole.Call() if r == 0 && err != nil { return true, fmt.Errorf("error allocating conhost: %s", err) } if err := initPanicFile(filepath.Join(root, "panic.log")); err != nil { return true, err } logOutput := ioutil.Discard if logFileFlag != "" { f, err := os.OpenFile(logFileFlag, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) if err != nil { return true, errors.Wrapf(err, "open log file %q", logFileFlag) } logOutput = f } logrus.SetOutput(logOutput) } return false, nil } // launchService is the entry point for running the daemon under SCM. func launchService(s *server.Server, done chan struct{}) error { if !runServiceFlag { return nil } h := &handler{ fromsvc: make(chan error), s: s, done: done, } interactive, err := svc.IsAnInteractiveSession() // nolint:staticcheck if err != nil { return err } go func() { if interactive { err = debug.Run(serviceNameFlag, h) } else { err = svc.Run(serviceNameFlag, h) } h.fromsvc <- err }() // Wait for the first signal from the service handler. err = <-h.fromsvc if err != nil { return err } return nil } func (h *handler) Execute(_ []string, r <-chan svc.ChangeRequest, s chan<- svc.Status) (bool, uint32) { s <- svc.Status{State: svc.StartPending, Accepts: 0} // Unblock launchService() h.fromsvc <- nil s <- svc.Status{State: svc.Running, Accepts: svc.AcceptStop | svc.AcceptShutdown | svc.Accepted(windows.SERVICE_ACCEPT_PARAMCHANGE)} Loop: for c := range r { switch c.Cmd { case svc.Interrogate: s <- c.CurrentStatus case svc.Stop, svc.Shutdown: s <- svc.Status{State: svc.StopPending, Accepts: 0} h.s.Stop() break Loop } } removePanicFile() close(h.done) return false, 0 } func initPanicFile(path string) error { var err error panicFile, err = os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644) if err != nil { return err } st, err := panicFile.Stat() if err != nil { return err } // If there are contents in the file already, move the file out of the way // and replace it. if st.Size() > 0 { panicFile.Close() os.Rename(path, path+".old") panicFile, err = os.Create(path) if err != nil { return err } } // Update STD_ERROR_HANDLE to point to the panic file so that Go writes to // it when it panics. Remember the old stderr to restore it before removing // the panic file. sh := uint32(windows.STD_ERROR_HANDLE) h, err := windows.GetStdHandle(sh) if err != nil { return err } oldStderr = h r, _, err := setStdHandle.Call(uintptr(sh), panicFile.Fd()) if r == 0 && err != nil { return err } // Reset os.Stderr to the panic file (so fmt.Fprintf(os.Stderr,...) actually gets redirected) os.Stderr = os.NewFile(panicFile.Fd(), "/dev/stderr") // Force threads that panic to write to stderr (the panicFile handle now), otherwise it will go into the ether log.SetOutput(os.Stderr) return nil } func removePanicFile() { if st, err := panicFile.Stat(); err == nil { if st.Size() == 0 { sh := uint32(windows.STD_ERROR_HANDLE) setStdHandle.Call(uintptr(sh), uintptr(oldStderr)) panicFile.Close() os.Remove(panicFile.Name()) } } } containerd-1.5.9/cmd/containerd/main.go000066400000000000000000000016371416535272200200360ustar00rootroot00000000000000/* Copyright The containerd 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 main import ( "fmt" "os" "github.com/containerd/containerd/cmd/containerd/command" "github.com/containerd/containerd/pkg/seed" ) func init() { seed.WithTimeAndRand() } func main() { app := command.App() if err := app.Run(os.Args); err != nil { fmt.Fprintf(os.Stderr, "containerd: %s\n", err) os.Exit(1) } } containerd-1.5.9/cmd/ctr/000077500000000000000000000000001416535272200152165ustar00rootroot00000000000000containerd-1.5.9/cmd/ctr/app/000077500000000000000000000000001416535272200157765ustar00rootroot00000000000000containerd-1.5.9/cmd/ctr/app/main.go000066400000000000000000000072151416535272200172560ustar00rootroot00000000000000/* Copyright The containerd 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 app import ( "fmt" "io/ioutil" "github.com/containerd/containerd/cmd/ctr/commands/containers" "github.com/containerd/containerd/cmd/ctr/commands/content" "github.com/containerd/containerd/cmd/ctr/commands/events" "github.com/containerd/containerd/cmd/ctr/commands/images" "github.com/containerd/containerd/cmd/ctr/commands/install" "github.com/containerd/containerd/cmd/ctr/commands/leases" namespacesCmd "github.com/containerd/containerd/cmd/ctr/commands/namespaces" ociCmd "github.com/containerd/containerd/cmd/ctr/commands/oci" "github.com/containerd/containerd/cmd/ctr/commands/plugins" "github.com/containerd/containerd/cmd/ctr/commands/pprof" "github.com/containerd/containerd/cmd/ctr/commands/run" "github.com/containerd/containerd/cmd/ctr/commands/snapshots" "github.com/containerd/containerd/cmd/ctr/commands/tasks" versionCmd "github.com/containerd/containerd/cmd/ctr/commands/version" "github.com/containerd/containerd/defaults" "github.com/containerd/containerd/namespaces" "github.com/containerd/containerd/version" "github.com/sirupsen/logrus" "github.com/urfave/cli" "google.golang.org/grpc/grpclog" ) var extraCmds = []cli.Command{} func init() { // Discard grpc logs so that they don't mess with our stdio grpclog.SetLoggerV2(grpclog.NewLoggerV2(ioutil.Discard, ioutil.Discard, ioutil.Discard)) cli.VersionPrinter = func(c *cli.Context) { fmt.Println(c.App.Name, version.Package, c.App.Version) } } // New returns a *cli.App instance. func New() *cli.App { app := cli.NewApp() app.Name = "ctr" app.Version = version.Version app.Description = ` ctr is an unsupported debug and administrative client for interacting with the containerd daemon. Because it is unsupported, the commands, options, and operations are not guaranteed to be backward compatible or stable from release to release of the containerd project.` app.Usage = ` __ _____/ /______ / ___/ __/ ___/ / /__/ /_/ / \___/\__/_/ containerd CLI ` app.EnableBashCompletion = true app.Flags = []cli.Flag{ cli.BoolFlag{ Name: "debug", Usage: "enable debug output in logs", }, cli.StringFlag{ Name: "address, a", Usage: "address for containerd's GRPC server", Value: defaults.DefaultAddress, EnvVar: "CONTAINERD_ADDRESS", }, cli.DurationFlag{ Name: "timeout", Usage: "total timeout for ctr commands", }, cli.DurationFlag{ Name: "connect-timeout", Usage: "timeout for connecting to containerd", }, cli.StringFlag{ Name: "namespace, n", Usage: "namespace to use with commands", Value: namespaces.Default, EnvVar: namespaces.NamespaceEnvVar, }, } app.Commands = append([]cli.Command{ plugins.Command, versionCmd.Command, containers.Command, content.Command, events.Command, images.Command, leases.Command, namespacesCmd.Command, pprof.Command, run.Command, snapshots.Command, tasks.Command, install.Command, ociCmd.Command, }, extraCmds...) app.Before = func(context *cli.Context) error { if context.GlobalBool("debug") { logrus.SetLevel(logrus.DebugLevel) } return nil } return app } containerd-1.5.9/cmd/ctr/app/main_unix.go000066400000000000000000000013631416535272200203170ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 app import "github.com/containerd/containerd/cmd/ctr/commands/shim" func init() { extraCmds = append(extraCmds, shim.Command) } containerd-1.5.9/cmd/ctr/commands/000077500000000000000000000000001416535272200170175ustar00rootroot00000000000000containerd-1.5.9/cmd/ctr/commands/client.go000066400000000000000000000035541416535272200206330ustar00rootroot00000000000000/* Copyright The containerd 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 commands import ( gocontext "context" "github.com/containerd/containerd" "github.com/containerd/containerd/namespaces" "github.com/urfave/cli" ) // AppContext returns the context for a command. Should only be called once per // command, near the start. // // This will ensure the namespace is picked up and set the timeout, if one is // defined. func AppContext(context *cli.Context) (gocontext.Context, gocontext.CancelFunc) { var ( ctx = gocontext.Background() timeout = context.GlobalDuration("timeout") namespace = context.GlobalString("namespace") cancel gocontext.CancelFunc ) ctx = namespaces.WithNamespace(ctx, namespace) if timeout > 0 { ctx, cancel = gocontext.WithTimeout(ctx, timeout) } else { ctx, cancel = gocontext.WithCancel(ctx) } return ctx, cancel } // NewClient returns a new containerd client func NewClient(context *cli.Context, opts ...containerd.ClientOpt) (*containerd.Client, gocontext.Context, gocontext.CancelFunc, error) { timeoutOpt := containerd.WithTimeout(context.GlobalDuration("connect-timeout")) opts = append(opts, timeoutOpt) client, err := containerd.New(context.GlobalString("address"), opts...) if err != nil { return nil, nil, nil, err } ctx, cancel := AppContext(context) return client, ctx, cancel, nil } containerd-1.5.9/cmd/ctr/commands/commands.go000066400000000000000000000142121416535272200211470ustar00rootroot00000000000000/* Copyright The containerd 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 commands import ( "encoding/json" "fmt" "os" "path/filepath" "strings" "github.com/containerd/containerd/defaults" "github.com/urfave/cli" ) var ( // SnapshotterFlags are cli flags specifying snapshotter names SnapshotterFlags = []cli.Flag{ cli.StringFlag{ Name: "snapshotter", Usage: "snapshotter name. Empty value stands for the default value.", EnvVar: "CONTAINERD_SNAPSHOTTER", }, } // LabelFlag is a cli flag specifying labels LabelFlag = cli.StringSliceFlag{ Name: "label", Usage: "labels to attach to the image", } // RegistryFlags are cli flags specifying registry options RegistryFlags = []cli.Flag{ cli.BoolFlag{ Name: "skip-verify,k", Usage: "skip SSL certificate validation", }, cli.BoolFlag{ Name: "plain-http", Usage: "allow connections using plain HTTP", }, cli.StringFlag{ Name: "user,u", Usage: "user[:password] Registry user and password", }, cli.StringFlag{ Name: "refresh", Usage: "refresh token for authorization server", }, cli.StringFlag{ Name: "hosts-dir", // compatible with "/etc/docker/certs.d" Usage: "Custom hosts configuration directory", }, cli.StringFlag{ Name: "tlscacert", Usage: "path to TLS root CA", }, cli.StringFlag{ Name: "tlscert", Usage: "path to TLS client certificate", }, cli.StringFlag{ Name: "tlskey", Usage: "path to TLS client key", }, cli.BoolFlag{ Name: "http-dump", Usage: "dump all HTTP request/responses when interacting with container registry", }, cli.BoolFlag{ Name: "http-trace", Usage: "enable HTTP tracing for registry interactions", }, } // ContainerFlags are cli flags specifying container options ContainerFlags = []cli.Flag{ cli.StringFlag{ Name: "config,c", Usage: "path to the runtime-specific spec config file", }, cli.StringFlag{ Name: "cwd", Usage: "specify the working directory of the process", }, cli.StringSliceFlag{ Name: "env", Usage: "specify additional container environment variables (e.g. FOO=bar)", }, cli.StringFlag{ Name: "env-file", Usage: "specify additional container environment variables in a file(e.g. FOO=bar, one per line)", }, cli.StringSliceFlag{ Name: "label", Usage: "specify additional labels (e.g. foo=bar)", }, cli.StringSliceFlag{ Name: "mount", Usage: "specify additional container mount (e.g. type=bind,src=/tmp,dst=/host,options=rbind:ro)", }, cli.BoolFlag{ Name: "net-host", Usage: "enable host networking for the container", }, cli.BoolFlag{ Name: "privileged", Usage: "run privileged container", }, cli.BoolFlag{ Name: "read-only", Usage: "set the containers filesystem as readonly", }, cli.StringFlag{ Name: "runtime", Usage: "runtime name", Value: defaults.DefaultRuntime, }, cli.StringFlag{ Name: "runtime-config-path", Usage: "optional runtime config path", }, cli.BoolFlag{ Name: "tty,t", Usage: "allocate a TTY for the container", }, cli.StringSliceFlag{ Name: "with-ns", Usage: "specify existing Linux namespaces to join at container runtime (format ':')", }, cli.StringFlag{ Name: "pid-file", Usage: "file path to write the task's pid", }, cli.IntFlag{ Name: "gpus", Usage: "add gpus to the container", }, cli.BoolFlag{ Name: "allow-new-privs", Usage: "turn off OCI spec's NoNewPrivileges feature flag", }, cli.Uint64Flag{ Name: "memory-limit", Usage: "memory limit (in bytes) for the container", }, cli.StringSliceFlag{ Name: "device", Usage: "file path to a device to add to the container; or a path to a directory tree of devices to add to the container", }, cli.BoolFlag{ Name: "seccomp", Usage: "enable the default seccomp profile", }, cli.StringFlag{ Name: "seccomp-profile", Usage: "file path to custom seccomp profile. seccomp must be set to true, before using seccomp-profile", }, cli.StringFlag{ Name: "apparmor-default-profile", Usage: "enable AppArmor with the default profile with the specified name, e.g. \"cri-containerd.apparmor.d\"", }, cli.StringFlag{ Name: "apparmor-profile", Usage: "enable AppArmor with an existing custom profile", }, } ) // ObjectWithLabelArgs returns the first arg and a LabelArgs object func ObjectWithLabelArgs(clicontext *cli.Context) (string, map[string]string) { var ( first = clicontext.Args().First() labelStrings = clicontext.Args().Tail() ) return first, LabelArgs(labelStrings) } // LabelArgs returns a map of label key,value pairs func LabelArgs(labelStrings []string) map[string]string { labels := make(map[string]string, len(labelStrings)) for _, label := range labelStrings { parts := strings.SplitN(label, "=", 2) key := parts[0] value := "true" if len(parts) > 1 { value = parts[1] } labels[key] = value } return labels } // PrintAsJSON prints input in JSON format func PrintAsJSON(x interface{}) { b, err := json.MarshalIndent(x, "", " ") if err != nil { fmt.Fprintf(os.Stderr, "can't marshal %+v as a JSON string: %v\n", x, err) } fmt.Println(string(b)) } // WritePidFile writes the pid atomically to a file func WritePidFile(path string, pid int) error { path, err := filepath.Abs(path) if err != nil { return err } tempPath := filepath.Join(filepath.Dir(path), fmt.Sprintf(".%s", filepath.Base(path))) f, err := os.OpenFile(tempPath, os.O_RDWR|os.O_CREATE|os.O_EXCL|os.O_SYNC, 0666) if err != nil { return err } _, err = fmt.Fprintf(f, "%d", pid) f.Close() if err != nil { return err } return os.Rename(tempPath, path) } containerd-1.5.9/cmd/ctr/commands/commands_unix.go000066400000000000000000000021051416535272200222100ustar00rootroot00000000000000// +build !windows /* Copyright The containerd 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 commands import ( "github.com/urfave/cli" ) func init() { ContainerFlags = append(ContainerFlags, cli.BoolFlag{ Name: "rootfs", Usage: "use custom rootfs that is not managed by containerd snapshotter", }, cli.BoolFlag{ Name: "no-pivot", Usage: "disable use of pivot-root (linux only)", }, cli.Int64Flag{ Name: "cpu-quota", Usage: "Limit CPU CFS quota", Value: -1, }, cli.Uint64Flag{ Name: "cpu-period", Usage: "Limit CPU CFS period", }) } containerd-1.5.9/cmd/ctr/commands/commands_windows.go000066400000000000000000000014671416535272200227310ustar00rootroot00000000000000// +build windows /* Copyright The containerd 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 commands import ( "github.com/urfave/cli" ) func init() { ContainerFlags = append(ContainerFlags, cli.Uint64Flag{ Name: "cpu-count", Usage: "number of CPUs available to the container", }) } containerd-1.5.9/cmd/ctr/commands/containers/000077500000000000000000000000001416535272200211645ustar00rootroot00000000000000containerd-1.5.9/cmd/ctr/commands/containers/checkpoint.go000066400000000000000000000046521416535272200236510ustar00rootroot00000000000000/* Copyright The containerd 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 containers import ( "fmt" "github.com/containerd/containerd" "github.com/containerd/containerd/cmd/ctr/commands" "github.com/containerd/containerd/errdefs" "github.com/pkg/errors" "github.com/urfave/cli" ) var checkpointCommand = cli.Command{ Name: "checkpoint", Usage: "checkpoint a container", ArgsUsage: "CONTAINER REF", Flags: []cli.Flag{ cli.BoolFlag{ Name: "rw", Usage: "include the rw layer in the checkpoint", }, cli.BoolFlag{ Name: "image", Usage: "include the image in the checkpoint", }, cli.BoolFlag{ Name: "task", Usage: "checkpoint container task", }, }, Action: func(context *cli.Context) error { id := context.Args().First() if id == "" { return errors.New("container id must be provided") } ref := context.Args().Get(1) if ref == "" { return errors.New("ref must be provided") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() opts := []containerd.CheckpointOpts{ containerd.WithCheckpointRuntime, } if context.Bool("image") { opts = append(opts, containerd.WithCheckpointImage) } if context.Bool("rw") { opts = append(opts, containerd.WithCheckpointRW) } if context.Bool("task") { opts = append(opts, containerd.WithCheckpointTask) } container, err := client.LoadContainer(ctx, id) if err != nil { return err } task, err := container.Task(ctx, nil) if err != nil { if !errdefs.IsNotFound(err) { return err } } // pause if running if task != nil { if err := task.Pause(ctx); err != nil { return err } defer func() { if err := task.Resume(ctx); err != nil { fmt.Println(errors.Wrap(err, "error resuming task")) } }() } if _, err := container.Checkpoint(ctx, ref, opts...); err != nil { return err } return nil }, } containerd-1.5.9/cmd/ctr/commands/containers/containers.go000066400000000000000000000165001416535272200236620ustar00rootroot00000000000000/* Copyright The containerd 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 containers import ( "context" "fmt" "os" "strings" "text/tabwriter" "github.com/containerd/containerd" "github.com/containerd/containerd/cio" "github.com/containerd/containerd/cmd/ctr/commands" "github.com/containerd/containerd/cmd/ctr/commands/run" "github.com/containerd/containerd/containers" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/log" "github.com/containerd/typeurl" "github.com/pkg/errors" "github.com/urfave/cli" ) // Command is the cli command for managing containers var Command = cli.Command{ Name: "containers", Usage: "manage containers", Aliases: []string{"c", "container"}, Subcommands: []cli.Command{ createCommand, deleteCommand, infoCommand, listCommand, setLabelsCommand, checkpointCommand, restoreCommand, }, } var createCommand = cli.Command{ Name: "create", Usage: "create container", ArgsUsage: "[flags] Image|RootFS CONTAINER [COMMAND] [ARG...]", Flags: append(commands.SnapshotterFlags, commands.ContainerFlags...), Action: func(context *cli.Context) error { var ( id string ref string config = context.IsSet("config") ) if config { id = context.Args().First() if context.NArg() > 1 { return errors.Wrap(errdefs.ErrInvalidArgument, "with spec config file, only container id should be provided") } } else { id = context.Args().Get(1) ref = context.Args().First() if ref == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "image ref must be provided") } } if id == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "container id must be provided") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() _, err = run.NewContainer(ctx, client, context) if err != nil { return err } return nil }, } var listCommand = cli.Command{ Name: "list", Aliases: []string{"ls"}, Usage: "list containers", ArgsUsage: "[flags] [, ...]", Flags: []cli.Flag{ cli.BoolFlag{ Name: "quiet, q", Usage: "print only the container id", }, }, Action: func(context *cli.Context) error { var ( filters = context.Args() quiet = context.Bool("quiet") ) client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() containers, err := client.Containers(ctx, filters...) if err != nil { return err } if quiet { for _, c := range containers { fmt.Printf("%s\n", c.ID()) } return nil } w := tabwriter.NewWriter(os.Stdout, 4, 8, 4, ' ', 0) fmt.Fprintln(w, "CONTAINER\tIMAGE\tRUNTIME\t") for _, c := range containers { info, err := c.Info(ctx, containerd.WithoutRefreshedMetadata) if err != nil { return err } imageName := info.Image if imageName == "" { imageName = "-" } if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t\n", c.ID(), imageName, info.Runtime.Name, ); err != nil { return err } } return w.Flush() }, } var deleteCommand = cli.Command{ Name: "delete", Usage: "delete one or more existing containers", ArgsUsage: "[flags] CONTAINER [CONTAINER, ...]", Aliases: []string{"del", "rm"}, Flags: []cli.Flag{ cli.BoolFlag{ Name: "keep-snapshot", Usage: "do not clean up snapshot with container", }, }, Action: func(context *cli.Context) error { var exitErr error client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() deleteOpts := []containerd.DeleteOpts{} if !context.Bool("keep-snapshot") { deleteOpts = append(deleteOpts, containerd.WithSnapshotCleanup) } if context.NArg() == 0 { return errors.Wrap(errdefs.ErrInvalidArgument, "must specify at least one container to delete") } for _, arg := range context.Args() { if err := deleteContainer(ctx, client, arg, deleteOpts...); err != nil { if exitErr == nil { exitErr = err } log.G(ctx).WithError(err).Errorf("failed to delete container %q", arg) } } return exitErr }, } func deleteContainer(ctx context.Context, client *containerd.Client, id string, opts ...containerd.DeleteOpts) error { container, err := client.LoadContainer(ctx, id) if err != nil { return err } task, err := container.Task(ctx, cio.Load) if err != nil { return container.Delete(ctx, opts...) } status, err := task.Status(ctx) if err != nil { return err } if status.Status == containerd.Stopped || status.Status == containerd.Created { if _, err := task.Delete(ctx); err != nil { return err } return container.Delete(ctx, opts...) } return fmt.Errorf("cannot delete a non stopped container: %v", status) } var setLabelsCommand = cli.Command{ Name: "label", Usage: "set and clear labels for a container", ArgsUsage: "[flags] CONTAINER [=, ...]", Description: "set and clear labels for a container", Flags: []cli.Flag{}, Action: func(context *cli.Context) error { containerID, labels := commands.ObjectWithLabelArgs(context) if containerID == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "container id must be provided") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() container, err := client.LoadContainer(ctx, containerID) if err != nil { return err } setlabels, err := container.SetLabels(ctx, labels) if err != nil { return err } var labelStrings []string for k, v := range setlabels { labelStrings = append(labelStrings, fmt.Sprintf("%s=%s", k, v)) } fmt.Println(strings.Join(labelStrings, ",")) return nil }, } var infoCommand = cli.Command{ Name: "info", Usage: "get info about a container", ArgsUsage: "CONTAINER", Flags: []cli.Flag{ cli.BoolFlag{ Name: "spec", Usage: "only display the spec", }, }, Action: func(context *cli.Context) error { id := context.Args().First() if id == "" { return errors.Wrap(errdefs.ErrInvalidArgument, "container id must be provided") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() container, err := client.LoadContainer(ctx, id) if err != nil { return err } info, err := container.Info(ctx, containerd.WithoutRefreshedMetadata) if err != nil { return err } if context.Bool("spec") { v, err := typeurl.UnmarshalAny(info.Spec) if err != nil { return err } commands.PrintAsJSON(v) return nil } if info.Spec != nil && info.Spec.Value != nil { v, err := typeurl.UnmarshalAny(info.Spec) if err != nil { return err } commands.PrintAsJSON(struct { containers.Container Spec interface{} `json:"Spec,omitempty"` }{ Container: info, Spec: v, }) return nil } commands.PrintAsJSON(info) return nil }, } containerd-1.5.9/cmd/ctr/commands/containers/restore.go000066400000000000000000000046541416535272200232070ustar00rootroot00000000000000/* Copyright The containerd 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 containers import ( "github.com/containerd/containerd" "github.com/containerd/containerd/cio" "github.com/containerd/containerd/cmd/ctr/commands" "github.com/containerd/containerd/errdefs" "github.com/pkg/errors" "github.com/urfave/cli" ) var restoreCommand = cli.Command{ Name: "restore", Usage: "restore a container from checkpoint", ArgsUsage: "CONTAINER REF", Flags: []cli.Flag{ cli.BoolFlag{ Name: "rw", Usage: "restore the rw layer from the checkpoint", }, cli.BoolFlag{ Name: "live", Usage: "restore the runtime and memory data from the checkpoint", }, }, Action: func(context *cli.Context) error { id := context.Args().First() if id == "" { return errors.New("container id must be provided") } ref := context.Args().Get(1) if ref == "" { return errors.New("ref must be provided") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() checkpoint, err := client.GetImage(ctx, ref) if err != nil { if !errdefs.IsNotFound(err) { return err } // TODO (ehazlett): consider other options (always/never fetch) ck, err := client.Fetch(ctx, ref) if err != nil { return err } checkpoint = containerd.NewImage(client, ck) } opts := []containerd.RestoreOpts{ containerd.WithRestoreImage, containerd.WithRestoreSpec, containerd.WithRestoreRuntime, } if context.Bool("rw") { opts = append(opts, containerd.WithRestoreRW) } ctr, err := client.Restore(ctx, id, checkpoint, opts...) if err != nil { return err } topts := []containerd.NewTaskOpts{} if context.Bool("live") { topts = append(topts, containerd.WithTaskCheckpoint(checkpoint)) } task, err := ctr.NewTask(ctx, cio.NewCreator(cio.WithStdio), topts...) if err != nil { return err } return task.Start(ctx) }, } containerd-1.5.9/cmd/ctr/commands/content/000077500000000000000000000000001416535272200204715ustar00rootroot00000000000000containerd-1.5.9/cmd/ctr/commands/content/content.go000066400000000000000000000325661416535272200225060ustar00rootroot00000000000000/* Copyright The containerd 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 content import ( "fmt" "io" "io/ioutil" "os" "os/exec" "strings" "text/tabwriter" "time" "github.com/containerd/containerd/cmd/ctr/commands" "github.com/containerd/containerd/content" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/log" units "github.com/docker/go-units" digest "github.com/opencontainers/go-digest" ocispec "github.com/opencontainers/image-spec/specs-go/v1" "github.com/pkg/errors" "github.com/urfave/cli" ) var ( // Command is the cli command for managing content Command = cli.Command{ Name: "content", Usage: "manage content", Subcommands: cli.Commands{ activeIngestCommand, deleteCommand, editCommand, fetchCommand, fetchObjectCommand, getCommand, ingestCommand, listCommand, pushObjectCommand, setLabelsCommand, pruneCommand, }, } getCommand = cli.Command{ Name: "get", Usage: "get the data for an object", ArgsUsage: "[, ...]", Description: "display the image object", Action: func(context *cli.Context) error { dgst, err := digest.Parse(context.Args().First()) if err != nil { return err } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() cs := client.ContentStore() ra, err := cs.ReaderAt(ctx, ocispec.Descriptor{Digest: dgst}) if err != nil { return err } defer ra.Close() // use 1MB buffer like we do for ingesting buf := make([]byte, 1<<20) _, err = io.CopyBuffer(os.Stdout, content.NewReader(ra), buf) return err }, } ingestCommand = cli.Command{ Name: "ingest", Usage: "accept content into the store", ArgsUsage: "[flags] ", Description: "ingest objects into the local content store", Flags: []cli.Flag{ cli.Int64Flag{ Name: "expected-size", Usage: "validate against provided size", }, cli.StringFlag{ Name: "expected-digest", Usage: "verify content against expected digest", }, }, Action: func(context *cli.Context) error { var ( ref = context.Args().First() expectedSize = context.Int64("expected-size") expectedDigest = digest.Digest(context.String("expected-digest")) ) if err := expectedDigest.Validate(); expectedDigest != "" && err != nil { return err } if ref == "" { return errors.New("must specify a transaction reference") } client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() cs := client.ContentStore() // TODO(stevvooe): Allow ingest to be reentrant. Currently, we expect // all data to be written in a single invocation. Allow multiple writes // to the same transaction key followed by a commit. return content.WriteBlob(ctx, cs, ref, os.Stdin, ocispec.Descriptor{Size: expectedSize, Digest: expectedDigest}) }, } activeIngestCommand = cli.Command{ Name: "active", Usage: "display active transfers", ArgsUsage: "[flags] []", Description: "display the ongoing transfers", Flags: []cli.Flag{ cli.DurationFlag{ Name: "timeout, t", Usage: "total timeout for fetch", EnvVar: "CONTAINERD_FETCH_TIMEOUT", }, cli.StringFlag{ Name: "root", Usage: "path to content store root", Value: "/tmp/content", // TODO(stevvooe): for now, just use the PWD/.content }, }, Action: func(context *cli.Context) error { match := context.Args().First() client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() cs := client.ContentStore() active, err := cs.ListStatuses(ctx, match) if err != nil { return err } tw := tabwriter.NewWriter(os.Stdout, 1, 8, 1, '\t', 0) fmt.Fprintln(tw, "REF\tSIZE\tAGE\t") for _, active := range active { fmt.Fprintf(tw, "%s\t%s\t%s\t\n", active.Ref, units.HumanSize(float64(active.Offset)), units.HumanDuration(time.Since(active.StartedAt))) } return tw.Flush() }, } listCommand = cli.Command{ Name: "list", Aliases: []string{"ls"}, Usage: "list all blobs in the store", ArgsUsage: "[flags]", Description: "list blobs in the content store", Flags: []cli.Flag{ cli.BoolFlag{ Name: "quiet, q", Usage: "print only the blob digest", }, }, Action: func(context *cli.Context) error { var ( quiet = context.Bool("quiet") args = []string(context.Args()) ) client, ctx, cancel, err := commands.NewClient(context) if err != nil { return err } defer cancel() cs := client.ContentStore() var walkFn content.WalkFunc if quiet { walkFn = func(info content.Info) error { fmt.Println(info.Digest) return nil } } else { tw := tabwriter.NewWriter(os.Stdout, 1, 8, 1, '\t', 0) defer tw.Flush() fmt.Fprintln(tw, "DIGEST\tSIZE\tAGE\tLABELS") walkFn = func(info content.Info) error { var labelStrings []string for k, v := range info.Labels { labelStrings = append(labelStrings, strings.Join([]string{k, v}, "=")) } labels := strings.Join(labelStrings, ",") if labels == "" { labels = "-" } fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n", info.Digest, units.HumanSize(float64(info.Size)), units.HumanDuration(time.Since(info.CreatedAt)), labels) return nil } } return cs.Walk(ctx, walkFn, args...) }, } setLabelsCommand = cli.Command{ Name: "label", Usage: "add labels to content", ArgsUsage: " [