pax_global_header00006660000000000000000000000064142145644000014512gustar00rootroot0000000000000052 comment=bd679cab506b8b8b75af2595624c3c3cd4254354 kvproto-6.1.0-alpha/000077500000000000000000000000001421456440000143055ustar00rootroot00000000000000kvproto-6.1.0-alpha/.gitattributes000066400000000000000000000001341421456440000171760ustar00rootroot00000000000000_vendor/** linguist-vendored pkg/** linguist-generated src/** linguist-generated kvproto-6.1.0-alpha/.github/000077500000000000000000000000001421456440000156455ustar00rootroot00000000000000kvproto-6.1.0-alpha/.github/workflows/000077500000000000000000000000001421456440000177025ustar00rootroot00000000000000kvproto-6.1.0-alpha/.github/workflows/cpp-test.yaml000066400000000000000000000033161421456440000223300ustar00rootroot00000000000000name: C++ Test on: push: branches: - master - release-5.0 - release-4.0 pull_request: branches: - master - release-5.0 - release-4.0 jobs: cpp-test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Install dependencies run: sudo apt install -y cmake clang libclang-dev llvm llvm-dev - name: Cache gRPC id: cache-grpc uses: actions/cache@v2 with: path: ~/grpcinstall/v1_26_0 key: ${{ runner.os }}-gRPC-v1_26_0-t0 - name: Install gRPC if: steps.cache-grpc.outputs.cache-hit != 'true' run: | export GRPC_INSTALL_PATH=~/grpcinstall/v1_26_0 && mkdir -p $GRPC_INSTALL_PATH git clone https://github.com/grpc/grpc.git pushd grpc && git checkout v1.26.0 && git submodule update --init mkdir -p grpcbuild && pushd grpcbuild && cmake .. -DgRPC_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$GRPC_INSTALL_PATH && make install && popd rm -rf grpcbuild && mkdir -p grpcbuild && pushd grpcbuild && cmake .. -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DgRPC_PROTOBUF_PROVIDER=package -DgRPC_ZLIB_PROVIDER=package -DgRPC_CARES_PROVIDER=package -DgRPC_SSL_PROVIDER=package -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$GRPC_INSTALL_PATH && make install && popd popd - name: Test C++ run: | export GRPC_INSTALL_PATH=~/grpcinstall/v1_26_0 export PATH="$GRPC_INSTALL_PATH/bin:$PATH" rm -rf kvprotobuild && mkdir kvprotobuild && pushd kvprotobuild && cmake ../cpp -DCMAKE_PREFIX_PATH=$GRPC_INSTALL_PATH && make && popd && rm -rf kvprotobuild kvproto-6.1.0-alpha/.github/workflows/golang-test.yaml000066400000000000000000000013711421456440000230140ustar00rootroot00000000000000name: Golang Test on: push: branches: - master - release-5.0 - release-4.0 - release-3.0 pull_request: branches: - master - release-5.0 - release-4.0 - release-3.0 jobs: golang-test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Download protoc env: PROTOC_VERSION: "3.8.0" run: | curl -L https://github.com/google/protobuf/releases/download/v$PROTOC_VERSION/protoc-$PROTOC_VERSION-linux-x86_64.zip -o protoc.zip &&\ unzip protoc.zip -d protoc - name: Test Golang run: | export PATH="$(pwd)/protoc/bin:$PATH" make go && git diff --quiet go.mod go.sum kvproto-6.1.0-alpha/.github/workflows/rust-test.yaml000066400000000000000000000012451421456440000225420ustar00rootroot00000000000000name: Rust Test on: push: branches: - master - release-5.0 - release-4.0 - release-3.0 pull_request: branches: - master - release-5.0 - release-4.0 - release-3.0 jobs: rust-test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v2 - name: Install dependencies run: sudo apt install -y cmake clang libclang-dev llvm llvm-dev - name: Test Rust env: RUST_TEST_THREADS: "1" RUST_BACKTRACE: "1" RUSTFLAGS: "-Dwarnings" CPLUS_INCLUDE_PATH: "/usr/lib/gcc/x86_64-linux-gnu/6/include" run: make rust kvproto-6.1.0-alpha/.gitignore000066400000000000000000000005231421456440000162750ustar00rootroot00000000000000target # ignore object files generated by golang compiler pkg/darwin_amd64/ pkg/linux_amd64/ # ignore source files downloaded by `go get` src/github.com/ # ignore binary file compiler by `go get` bin/ _vendor/bin _vendor/pkg Cargo.lock .vscode .idea _tools cpp/ !cpp/cmake/ !cpp/CMakeLists.txt proto-cpp/ kvprotobuild .DS_Store /protoc kvproto-6.1.0-alpha/Cargo.toml000066400000000000000000000022601421456440000162350ustar00rootroot00000000000000[package] name = "kvproto" version = "0.0.2" keywords = ["TiKV"] edition = "2018" build = "build.rs" [lib] name = "kvproto" path = "src/lib.rs" [features] default = ["protobuf-codec"] protobuf-codec = ["protobuf-build/grpcio-protobuf-codec", "raft-proto/protobuf-codec", "grpcio/protobuf-codec"] prost-codec = ["prost", "prost-derive", "lazy_static", "protobuf-build/grpcio-prost-codec", "raft-proto/prost-codec", "grpcio/prost-codec"] [dependencies] protobuf = "=2.8.0" prost = { version = "0.9", optional = true } prost-derive = { version = "0.9", optional = true } futures = "0.3.5" raft-proto = { version = "0.7.0", default-features = false } grpcio = { version = "0.10.0", default-features = false } lazy_static = { version = "1.3", optional = true } [build-dependencies] protobuf-build = { version = "0.13", default-features = false } [patch.crates-io] raft-proto = { git = "https://github.com/tikv/raft-rs", rev="95c532612ee6a83591fce9a8b51d6afe87b58835"} protobuf-codegen = { git = "https://github.com/pingcap/rust-protobuf", rev="82b49fea7e696fd647b5aca0a6c6ec944eab3189" } protobuf = { git = "https://github.com/pingcap/rust-protobuf", rev="82b49fea7e696fd647b5aca0a6c6ec944eab3189" } kvproto-6.1.0-alpha/Dockerfile000066400000000000000000000035331421456440000163030ustar00rootroot00000000000000FROM ubuntu:20.04 # If the timezone is not set the apt install will become interactive ENV TZ=UTC RUN echo "UTC" >> /etc/timezone RUN apt-get update --yes \ && apt-get install --yes tzdata \ && dpkg-reconfigure --frontend noninteractive tzdata \ && echo "deps for Rust and C++" \ && apt-get install --yes cmake clang libclang-dev llvm llvm-dev \ && echo "deps for building C++" \ && apt-get install --yes git golang libssl-dev \ && rm -rf /var/lib/apt/lists/* # C++ setup ENV GRPC_INSTALL_PATH=/grpcinstall/v1_26_0 ENV PATH="/usr/lib/protoc/bin:$GRPC_INSTALL_PATH/bin:$PATH" # C++ setup RUN mkdir -p $GRPC_INSTALL_PATH \ && git clone https://github.com/grpc/grpc.git \ && cd grpc \ && git checkout v1.26.0 \ && git submodule update --init \ && mkdir -p grpcbuild \ && cd grpcbuild \ && cmake .. -DgRPC_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$GRPC_INSTALL_PATH \ && make install \ && cd .. \ && rm -rf grpcbuild \ && mkdir -p grpcbuild \ && cd grpcbuild \ && cmake .. -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DgRPC_PROTOBUF_PROVIDER=package -DgRPC_ZLIB_PROVIDER=package -DgRPC_CARES_PROVIDER=package -DgRPC_SSL_PROVIDER=package -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$GRPC_INSTALL_PATH && make install \ && cd .. # Golang setup RUN apt-get update --yes \ && apt-get install --yes curl unzip \ && rm -rf /var/lib/apt/lists/* # Protoc setup ENV PROTOC_VERSION "3.8.0" RUN curl -L https://github.com/google/protobuf/releases/download/v$PROTOC_VERSION/protoc-$PROTOC_VERSION-linux-x86_64.zip -o protoc.zip && \ unzip protoc.zip -d protoc && \ mv protoc /usr/lib/ ## Rust setup ENV RUST_TEST_THREADS "1" ENV RUST_BACKTRACE "1" ENV RUSTFLAGS "-Dwarnings" ENV CPLUS_INCLUDE_PATH "/usr/lib/gcc/x86_64-linux-gnu/6/include" RUN apt-get update --yes \ && apt-get install --yes cargo \ && rm -rf /var/lib/apt/lists/* kvproto-6.1.0-alpha/LICENSE000066400000000000000000000260361421456440000153210ustar00rootroot00000000000000Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. kvproto-6.1.0-alpha/Makefile000066400000000000000000000010141421456440000157410ustar00rootroot00000000000000### Makefile for kvproto CURDIR := $(shell pwd) export PATH := $(CURDIR)/bin/:$(PATH) all: go rust c++ init: mkdir -p $(CURDIR)/bin check: init $(CURDIR)/scripts/check.sh go: check # Standalone GOPATH $(CURDIR)/scripts/generate_go.sh GO111MODULE=on go mod tidy GO111MODULE=on go build ./pkg/... rust: init cargo check && \ cargo check --no-default-features --features prost-codec c++: check mkdir -p kvprotobuild && cd kvprotobuild && cmake ../cpp -DCMAKE_PREFIX_PATH=$$GRPC_INSTALL_PATH && make .PHONY: all kvproto-6.1.0-alpha/README.md000066400000000000000000000013341421456440000155650ustar00rootroot00000000000000# kvproto Protocol buffer files for TiKV # Usage + Write your own protocol file in proto folder. + If you need to update raft-rs, please download the proto file respectively and overwrite the one in include folder. + Run `make` to generate go and rust code. We generate all go codes in pkg folder and rust in src folder. + Update the dependent projects. # Dependencies * Rust * Go * Protoc 3.8.0 # Docker image The easiest way to compile the protobufs is to use docker. ``` ./scripts/docker-build.sh # build the docker image once ./scripts/docker-run.sh make go ``` # Build locally There are many dependencies to be installed, please refer to the relevant scripts in [workflow](.github/workflows) to set them up. kvproto-6.1.0-alpha/build.rs000066400000000000000000000012471421456440000157560ustar00rootroot00000000000000// Copyright 2019 PingCAP, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. use protobuf_build::Builder; fn main() { Builder::new() .search_dir_for_protos("proto") .append_to_black_list("eraftpb") .generate() } kvproto-6.1.0-alpha/cpp/000077500000000000000000000000001421456440000150675ustar00rootroot00000000000000kvproto-6.1.0-alpha/cpp/CMakeLists.txt000066400000000000000000000130251421456440000176300ustar00rootroot00000000000000project (kvproto) cmake_minimum_required (VERSION 2.8.12) set (CMAKE_CXX_STANDARD 17) if (CMAKE_VERSION VERSION_LESS "3.8.0") set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1z") else () set (CMAKE_CXX_STANDARD 17) set (CMAKE_CXX_EXTENSIONS 1) # https://cmake.org/cmake/help/latest/prop_tgt/CXX_EXTENSIONS.html#prop_tgt:CXX_EXTENSIONS set (CMAKE_CXX_STANDARD_REQUIRED ON) endif () set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") if (NOT Protobuf_INCLUDE_DIR) include (cmake/find_protobuf.cmake) endif () if (NOT gRPC_FOUND) include (cmake/find_grpc.cmake) endif () # .proto files under "proto" set (PROTO_DEF_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../proto") file (GLOB PROTO_DEFS "${PROTO_DEF_DIR}/*.proto") # .proto files under "include" set (PROTO_INC_DEF_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../include") get_filename_component (PROTO_INC_DEF_DIR ${PROTO_INC_DEF_DIR} ABSOLUTE) file (GLOB PROTO_INC_DEFS "${PROTO_INC_DEF_DIR}/*.proto") list (APPEND PROTO_INC_DEFS "${PROTO_INC_DEF_DIR}/google/api/http.proto" "${PROTO_INC_DEF_DIR}/google/api/annotations.proto" ) # The output dir for .pb.h, .pb.cc set (PROTO_OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/kvproto") file (MAKE_DIRECTORY "${PROTO_OUTPUT_DIR}") # A temporary directory for proto file without gogoproto marks set (PROTO_DEF_TMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/protos") file (MAKE_DIRECTORY "${PROTO_DEF_TMP_DIR}") set (CLEAN_PROTO_DEFS "") foreach (F ${PROTO_DEFS}) get_filename_component (ABS_FIL ${F} ABSOLUTE) get_filename_component (FIL_WE ${F} NAME_WE) list (APPEND CLEAN_PROTO_DEFS "${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto") # Generate a output file by copying and cleaning up gogoproto marks. # Will be re-generated if the original .proto file is changed. add_custom_command( OUTPUT "${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto" WORKING_DIRECTORY ${PROTO_DEF_DIR} COMMAND cp ${ABS_FIL} ${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto COMMAND bash -c "source ${CMAKE_CURRENT_SOURCE_DIR}/../scripts/common.sh && clean_gogo_proto ${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto" DEPENDS ${ABS_FIL} COMMENT "Generating clean proto file on ${ABS_FIL}" VERBATIM) endforeach() # Grab all clean .proto files as a target add_custom_target (__clean_kvproto_defs DEPENDS ${CLEAN_PROTO_DEFS} VERBATIM) set (PROTO_SRCS "") set (PROTO_HDRS "") foreach (F ${PROTO_INC_DEFS}) # .proto under "include" get_filename_component (ABS_FIL ${F} ABSOLUTE) # We need relative path for .proto under subdirectory string(REPLACE "${PROTO_INC_DEF_DIR}/" "" RELA_FIL ${ABS_FIL}) string(REPLACE ".proto" ".pb.cc" PROTO_SRC ${RELA_FIL}) string(REPLACE ".proto" ".pb.h" PROTO_HDR ${RELA_FIL}) # message(STATUS "${F} ${ABS_FIL} ${RELA_FIL}") list (APPEND PROTO_SRCS "${PROTO_OUTPUT_DIR}/${PROTO_SRC}") list (APPEND PROTO_HDRS "${PROTO_OUTPUT_DIR}/${PROTO_HDR}") # Create the generated cpp files for .proto file. # Add dependency on the original .proto file # so that it can re-generate source files if .proto changed. add_custom_command( OUTPUT "${PROTO_OUTPUT_DIR}/${PROTO_SRC}" "${PROTO_OUTPUT_DIR}/${PROTO_HDR}" WORKING_DIRECTORY ${PROTO_INC_DEF_DIR} COMMAND ${Protobuf_PROTOC_EXECUTABLE} ARGS --cpp_out=${PROTO_OUTPUT_DIR} -I=${PROTO_DEF_TMP_DIR}:${PROTO_INC_DEF_DIR} ${RELA_FIL} DEPENDS ${ABS_FIL} ${Protobuf_PROTOC_EXECUTABLE} __clean_kvproto_defs COMMENT "Running C++ protocol buffer compiler on ${ABS_FIL}" VERBATIM) endforeach() # end for .proto under "include" foreach (F ${PROTO_DEFS}) # .proto under "proto" get_filename_component (ABS_FIL ${F} ABSOLUTE) get_filename_component (FIL_WE ${F} NAME_WE) # message(STATUS "${F} ${ABS_FIL}") list (APPEND PROTO_SRCS "${PROTO_OUTPUT_DIR}/${FIL_WE}.pb.cc") list (APPEND PROTO_HDRS "${PROTO_OUTPUT_DIR}/${FIL_WE}.pb.h") # Need to appen grpc services files list (APPEND PROTO_SRCS "${PROTO_OUTPUT_DIR}/${FIL_WE}.grpc.pb.cc") list (APPEND PROTO_HDRS "${PROTO_OUTPUT_DIR}/${FIL_WE}.grpc.pb.h") # Create the generated cpp files for .proto file. # Add dependency on the original .proto file and `__clean_kvproto_defs` # so that it can re-generate source files if .proto changed. add_custom_command( OUTPUT "${PROTO_OUTPUT_DIR}/${FIL_WE}.pb.cc" "${PROTO_OUTPUT_DIR}/${FIL_WE}.pb.h" WORKING_DIRECTORY ${PROTO_DEF_TMP_DIR} COMMAND ${Protobuf_PROTOC_EXECUTABLE} ARGS --cpp_out=${PROTO_OUTPUT_DIR} -I=${PROTO_DEF_TMP_DIR}:${PROTO_INC_DEF_DIR} ${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto # And also grpc service COMMAND ${Protobuf_PROTOC_EXECUTABLE} ARGS --grpc_out=${PROTO_OUTPUT_DIR} -I=${PROTO_DEF_TMP_DIR}:${PROTO_INC_DEF_DIR} --plugin=protoc-gen-grpc=${gRPC_CPP_PLUGIN} ${PROTO_DEF_TMP_DIR}/${FIL_WE}.proto DEPENDS ${ABS_FIL} ${Protobuf_PROTOC_EXECUTABLE} ${gRPC_CPP_PLUGIN} __clean_kvproto_defs COMMENT "Running C++ protocol buffer compiler on ${ABS_FIL}" VERBATIM) endforeach() # end for .proto under "proto" # Mark those clean .proto, .pb.h, .pb.cc files are generated # so that they can be re-build if changed and clean by `make clean` set_source_files_properties( ${CLEAN_PROTO_DEFS} ${PROTO_SRCS} ${PROTO_HDRS} PROPERTIES GENERATED TRUE ) add_library(kvproto ${PROTO_SRCS} ${PROTO_HDRS} ) target_include_directories(kvproto PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/kvproto ${Protobuf_INCLUDE_DIR} ${gRPC_INCLUDE_DIRS} ) kvproto-6.1.0-alpha/cpp/cmake/000077500000000000000000000000001421456440000161475ustar00rootroot00000000000000kvproto-6.1.0-alpha/cpp/cmake/Modules/000077500000000000000000000000001421456440000175575ustar00rootroot00000000000000kvproto-6.1.0-alpha/cpp/cmake/Modules/FindPackageHandleStandardArgs.cmake000066400000000000000000000541061421456440000263350ustar00rootroot00000000000000# Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. #[=======================================================================[.rst: FindPackageHandleStandardArgs ----------------------------- This module provides functions intended to be used in :ref:`Find Modules` implementing :command:`find_package()` calls. .. command:: find_package_handle_standard_args This command handles the ``REQUIRED``, ``QUIET`` and version-related arguments of :command:`find_package`. It also sets the ``_FOUND`` variable. The package is considered found if all variables listed contain valid results, e.g. valid filepaths. There are two signatures: .. code-block:: cmake find_package_handle_standard_args( (DEFAULT_MSG|) ... ) find_package_handle_standard_args( [FOUND_VAR ] [REQUIRED_VARS ...] [VERSION_VAR ] [HANDLE_VERSION_RANGE] [HANDLE_COMPONENTS] [CONFIG_MODE] [NAME_MISMATCHED] [REASON_FAILURE_MESSAGE ] [FAIL_MESSAGE ] ) The ``_FOUND`` variable will be set to ``TRUE`` if all the variables ``...`` are valid and any optional constraints are satisfied, and ``FALSE`` otherwise. A success or failure message may be displayed based on the results and on whether the ``REQUIRED`` and/or ``QUIET`` option was given to the :command:`find_package` call. The options are: ``(DEFAULT_MSG|)`` In the simple signature this specifies the failure message. Use ``DEFAULT_MSG`` to ask for a default message to be computed (recommended). Not valid in the full signature. ``FOUND_VAR `` Obsolete. Specifies either ``_FOUND`` or ``_FOUND`` as the result variable. This exists only for compatibility with older versions of CMake and is now ignored. Result variables of both names are always set for compatibility. ``REQUIRED_VARS ...`` Specify the variables which are required for this package. These may be named in the generated failure message asking the user to set the missing variable values. Therefore these should typically be cache entries such as ``FOO_LIBRARY`` and not output variables like ``FOO_LIBRARIES``. This option is mandatory if ``HANDLE_COMPONENTS`` is not specified. ``VERSION_VAR `` Specify the name of a variable that holds the version of the package that has been found. This version will be checked against the (potentially) specified required version given to the :command:`find_package` call, including its ``EXACT`` option. The default messages include information about the required version and the version which has been actually found, both if the version is ok or not. ``HANDLE_VERSION_RANGE`` Enable handling of a version range, if one is specified. Without this option, a developer warning will be displayed if a version range is specified. ``HANDLE_COMPONENTS`` Enable handling of package components. In this case, the command will report which components have been found and which are missing, and the ``_FOUND`` variable will be set to ``FALSE`` if any of the required components (i.e. not the ones listed after the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are missing. ``CONFIG_MODE`` Specify that the calling find module is a wrapper around a call to ``find_package( NO_MODULE)``. This implies a ``VERSION_VAR`` value of ``_VERSION``. The command will automatically check whether the package configuration file was found. ``REASON_FAILURE_MESSAGE `` Specify a custom message of the reason for the failure which will be appended to the default generated message. ``FAIL_MESSAGE `` Specify a custom failure message instead of using the default generated message. Not recommended. ``NAME_MISMATCHED`` Indicate that the ```` does not match ``${CMAKE_FIND_PACKAGE_NAME}``. This is usually a mistake and raises a warning, but it may be intentional for usage of the command for components of a larger package. Example for the simple signature: .. code-block:: cmake find_package_handle_standard_args(LibXml2 DEFAULT_MSG LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) The ``LibXml2`` package is considered to be found if both ``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid. Then also ``LibXml2_FOUND`` is set to ``TRUE``. If it is not found and ``REQUIRED`` was used, it fails with a :command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was used or not. If it is found, success will be reported, including the content of the first ````. On repeated CMake runs, the same message will not be printed again. .. note:: If ```` does not match ``CMAKE_FIND_PACKAGE_NAME`` for the calling module, a warning that there is a mismatch is given. The ``FPHSA_NAME_MISMATCHED`` variable may be set to bypass the warning if using the old signature and the ``NAME_MISMATCHED`` argument using the new signature. To avoid forcing the caller to require newer versions of CMake for usage, the variable's value will be used if defined when the ``NAME_MISMATCHED`` argument is not passed for the new signature (but using both is an error).. Example for the full signature: .. code-block:: cmake find_package_handle_standard_args(LibArchive REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR VERSION_VAR LibArchive_VERSION) In this case, the ``LibArchive`` package is considered to be found if both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid. Also the version of ``LibArchive`` will be checked by using the version contained in ``LibArchive_VERSION``. Since no ``FAIL_MESSAGE`` is given, the default messages will be printed. Another example for the full signature: .. code-block:: cmake find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) find_package_handle_standard_args(Automoc4 CONFIG_MODE) In this case, a ``FindAutmoc4.cmake`` module wraps a call to ``find_package(Automoc4 NO_MODULE)`` and adds an additional search directory for ``automoc4``. Then the call to ``find_package_handle_standard_args`` produces a proper success/failure message. .. command:: find_package_check_version Helper function which can be used to check if a ```` is valid against version-related arguments of :command:`find_package`. .. code-block:: cmake find_package_check_version( [HANDLE_VERSION_RANGE] [RESULT_MESSAGE_VARIABLE ] ) The ```` will hold a boolean value giving the result of the check. The options are: ``HANDLE_VERSION_RANGE`` Enable handling of a version range, if one is specified. Without this option, a developer warning will be displayed if a version range is specified. ``RESULT_MESSAGE_VARIABLE `` Specify a variable to get back a message describing the result of the check. Example for the usage: .. code-block:: cmake find_package_check_version(1.2.3 result HANDLE_VERSION_RANGE RESULT_MESSAGE_VARIABLE reason) if (result) message (STATUS "${reason}") else() message (FATAL_ERROR "${reason}") endif() #]=======================================================================] include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) cmake_policy(PUSH) # numbers and boolean constants cmake_policy (SET CMP0012 NEW) # IN_LIST operator cmake_policy (SET CMP0057 NEW) # internal helper macro macro(_FPHSA_FAILURE_MESSAGE _msg) set (__msg "${_msg}") if (FPHSA_REASON_FAILURE_MESSAGE) string(APPEND __msg "\n Reason given by package: ${FPHSA_REASON_FAILURE_MESSAGE}\n") endif() if (${_NAME}_FIND_REQUIRED) message(FATAL_ERROR "${__msg}") else () if (NOT ${_NAME}_FIND_QUIETLY) message(STATUS "${__msg}") endif () endif () endmacro() # internal helper macro to generate the failure message when used in CONFIG_MODE: macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) # _CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: if(${_NAME}_CONFIG) _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") else() # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. # List them all in the error message: if(${_NAME}_CONSIDERED_CONFIGS) set(configsText "") list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) math(EXPR configsCount "${configsCount} - 1") foreach(currentConfigIndex RANGE ${configsCount}) list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) string(APPEND configsText "\n ${filename} (version ${version})") endforeach() if (${_NAME}_NOT_FOUND_MESSAGE) if (FPHSA_REASON_FAILURE_MESSAGE) string(PREPEND FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}\n ") else() set(FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}") endif() else() string(APPEND configsText "\n") endif() _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:${configsText}") else() # Simple case: No Config-file was found at all: _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") endif() endif() endmacro() function(FIND_PACKAGE_CHECK_VERSION version result) cmake_parse_arguments (PARSE_ARGV 2 FPCV "HANDLE_VERSION_RANGE;NO_AUTHOR_WARNING_VERSION_RANGE" "RESULT_MESSAGE_VARIABLE" "") if (FPCV_UNPARSED_ARGUMENTS) message (FATAL_ERROR "find_package_check_version(): ${FPCV_UNPARSED_ARGUMENTS}: unexpected arguments") endif() if ("RESULT_MESSAGE_VARIABLE" IN_LIST FPCV_KEYWORDS_MISSING_VALUES) message (FATAL_ERROR "find_package_check_version(): RESULT_MESSAGE_VARIABLE expects an argument") endif() set (${result} FALSE PARENT_SCOPE) if (FPCV_RESULT_MESSAGE_VARIABLE) unset (${FPCV_RESULT_MESSAGE_VARIABLE} PARENT_SCOPE) endif() if (CMAKE_FIND_PACKAGE_NAME) set (package ${CMAKE_FIND_PACKAGE_NAME}) else() message (FATAL_ERROR "find_package_check_version(): Cannot be used outside a 'Find Module'") endif() if (NOT FPCV_NO_AUTHOR_WARNING_VERSION_RANGE AND ${package}_FIND_VERSION_RANGE AND NOT FPCV_HANDLE_VERSION_RANGE) message(AUTHOR_WARNING "`find_package()` specify a version range but the option " "HANDLE_VERSION_RANGE` is not passed to `find_package_check_version()`. " "Only the lower endpoint of the range will be used.") endif() set (version_ok FALSE) unset (version_msg) if (FPCV_HANDLE_VERSION_RANGE AND ${package}_FIND_VERSION_RANGE) if ((${package}_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND version VERSION_GREATER_EQUAL ${package}_FIND_VERSION_MIN) AND ((${package}_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND version VERSION_LESS_EQUAL ${package}_FIND_VERSION_MAX) OR (${package}_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND version VERSION_LESS ${package}_FIND_VERSION_MAX))) set (version_ok TRUE) set(version_msg "(found suitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\")") else() set(version_msg "Found unsuitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\"") endif() elseif (DEFINED ${package}_FIND_VERSION) if(${package}_FIND_VERSION_EXACT) # exact version required # count the dots in the version string string(REGEX REPLACE "[^.]" "" version_dots "${version}") # add one dot because there is one dot more than there are components string(LENGTH "${version_dots}." version_dots) if (version_dots GREATER ${package}_FIND_VERSION_COUNT) # Because of the C++ implementation of find_package() ${package}_FIND_VERSION_COUNT # is at most 4 here. Therefore a simple lookup table is used. if (${package}_FIND_VERSION_COUNT EQUAL 1) set(version_regex "[^.]*") elseif (${package}_FIND_VERSION_COUNT EQUAL 2) set(version_regex "[^.]*\\.[^.]*") elseif (${package}_FIND_VERSION_COUNT EQUAL 3) set(version_regex "[^.]*\\.[^.]*\\.[^.]*") else() set(version_regex "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") endif() string(REGEX REPLACE "^(${version_regex})\\..*" "\\1" version_head "${version}") if (NOT ${package}_FIND_VERSION VERSION_EQUAL version_head) set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"") else () set(version_ok TRUE) set(version_msg "(found suitable exact version \"${_FOUND_VERSION}\")") endif () else () if (NOT ${package}_FIND_VERSION VERSION_EQUAL version) set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"") else () set(version_ok TRUE) set(version_msg "(found suitable exact version \"${version}\")") endif () endif () else() # minimum version if (${package}_FIND_VERSION VERSION_GREATER version) set(version_msg "Found unsuitable version \"${version}\", but required is at least \"${${package}_FIND_VERSION}\"") else() set(version_ok TRUE) set(version_msg "(found suitable version \"${version}\", minimum required is \"${${package}_FIND_VERSION}\")") endif() endif() else () set(version_ok TRUE) set(version_msg "(found version \"${version}\")") endif() set (${result} ${version_ok} PARENT_SCOPE) if (FPCV_RESULT_MESSAGE_VARIABLE) set (${FPCV_RESULT_MESSAGE_VARIABLE} "${version_msg}" PARENT_SCOPE) endif() endfunction() function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) # Set up the arguments for `cmake_parse_arguments`. set(options CONFIG_MODE HANDLE_COMPONENTS NAME_MISMATCHED HANDLE_VERSION_RANGE) set(oneValueArgs FAIL_MESSAGE REASON_FAILURE_MESSAGE VERSION_VAR FOUND_VAR) set(multiValueArgs REQUIRED_VARS) # Check whether we are in 'simple' or 'extended' mode: set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) unset(FPHSA_NAME_MISMATCHED_override) if (DEFINED FPHSA_NAME_MISMATCHED) # If the variable NAME_MISMATCHED variable is set, error if it is passed as # an argument. The former is for old signatures, the latter is for new # signatures. list(FIND ARGN "NAME_MISMATCHED" name_mismatched_idx) if (NOT name_mismatched_idx EQUAL "-1") message(FATAL_ERROR "The `NAME_MISMATCHED` argument may only be specified by the argument or " "the variable, not both.") endif () # But use the variable if it is not an argument to avoid forcing minimum # CMake version bumps for calling modules. set(FPHSA_NAME_MISMATCHED_override "${FPHSA_NAME_MISMATCHED}") endif () if(${INDEX} EQUAL -1) set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) set(FPHSA_REQUIRED_VARS ${ARGN}) set(FPHSA_VERSION_VAR) else() cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) if(FPHSA_UNPARSED_ARGUMENTS) message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") endif() if(NOT FPHSA_FAIL_MESSAGE) set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") endif() # In config-mode, we rely on the variable _CONFIG, which is set by find_package() # when it successfully found the config-file, including version checking: if(FPHSA_CONFIG_MODE) list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) set(FPHSA_VERSION_VAR ${_NAME}_VERSION) endif() if(NOT FPHSA_REQUIRED_VARS AND NOT FPHSA_HANDLE_COMPONENTS) message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") endif() endif() if (DEFINED FPHSA_NAME_MISMATCHED_override) set(FPHSA_NAME_MISMATCHED "${FPHSA_NAME_MISMATCHED_override}") endif () if (DEFINED CMAKE_FIND_PACKAGE_NAME AND NOT FPHSA_NAME_MISMATCHED AND NOT _NAME STREQUAL CMAKE_FIND_PACKAGE_NAME) message(AUTHOR_WARNING "The package name passed to `find_package_handle_standard_args` " "(${_NAME}) does not match the name of the calling package " "(${CMAKE_FIND_PACKAGE_NAME}). This can lead to problems in calling " "code that expects `find_package` result variables (e.g., `_FOUND`) " "to follow a certain pattern.") endif () if (${_NAME}_FIND_VERSION_RANGE AND NOT FPHSA_HANDLE_VERSION_RANGE) message(AUTHOR_WARNING "`find_package()` specify a version range but the module ${_NAME} does " "not support this capability. Only the lower endpoint of the range " "will be used.") endif() # now that we collected all arguments, process them if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG") set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") endif() if (FPHSA_REQUIRED_VARS) list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) endif() string(TOUPPER ${_NAME} _NAME_UPPER) string(TOLOWER ${_NAME} _NAME_LOWER) if(FPHSA_FOUND_VAR) set(_FOUND_VAR_UPPER ${_NAME_UPPER}_FOUND) set(_FOUND_VAR_MIXED ${_NAME}_FOUND) if(FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_MIXED OR FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_UPPER) set(_FOUND_VAR ${FPHSA_FOUND_VAR}) else() message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_FOUND_VAR_MIXED}\" and \"${_FOUND_VAR_UPPER}\" are valid names.") endif() else() set(_FOUND_VAR ${_NAME_UPPER}_FOUND) endif() # collect all variables which were not found, so they can be printed, so the # user knows better what went wrong (#6375) set(MISSING_VARS "") set(DETAILS "") # check if all passed variables are valid set(FPHSA_FOUND_${_NAME} TRUE) foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) if(NOT ${_CURRENT_VAR}) set(FPHSA_FOUND_${_NAME} FALSE) string(APPEND MISSING_VARS " ${_CURRENT_VAR}") else() string(APPEND DETAILS "[${${_CURRENT_VAR}}]") endif() endforeach() if(FPHSA_FOUND_${_NAME}) set(${_NAME}_FOUND TRUE) set(${_NAME_UPPER}_FOUND TRUE) else() set(${_NAME}_FOUND FALSE) set(${_NAME_UPPER}_FOUND FALSE) endif() # component handling unset(FOUND_COMPONENTS_MSG) unset(MISSING_COMPONENTS_MSG) if(FPHSA_HANDLE_COMPONENTS) foreach(comp ${${_NAME}_FIND_COMPONENTS}) if(${_NAME}_${comp}_FOUND) if(NOT DEFINED FOUND_COMPONENTS_MSG) set(FOUND_COMPONENTS_MSG "found components:") endif() string(APPEND FOUND_COMPONENTS_MSG " ${comp}") else() if(NOT DEFINED MISSING_COMPONENTS_MSG) set(MISSING_COMPONENTS_MSG "missing components:") endif() string(APPEND MISSING_COMPONENTS_MSG " ${comp}") if(${_NAME}_FIND_REQUIRED_${comp}) set(${_NAME}_FOUND FALSE) string(APPEND MISSING_VARS " ${comp}") endif() endif() endforeach() set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") string(APPEND DETAILS "[c${COMPONENT_MSG}]") endif() # version handling: set(VERSION_MSG "") set(VERSION_OK TRUE) # check with DEFINED here as the requested or found version may be "0" if (DEFINED ${_NAME}_FIND_VERSION) if(DEFINED ${FPHSA_VERSION_VAR}) set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}}) if (FPHSA_HANDLE_VERSION_RANGE) set (FPCV_HANDLE_VERSION_RANGE HANDLE_VERSION_RANGE) else() set(FPCV_HANDLE_VERSION_RANGE NO_AUTHOR_WARNING_VERSION_RANGE) endif() find_package_check_version ("${_FOUND_VERSION}" VERSION_OK RESULT_MESSAGE_VARIABLE VERSION_MSG ${FPCV_HANDLE_VERSION_RANGE}) else() # if the package was not found, but a version was given, add that to the output: if(${_NAME}_FIND_VERSION_EXACT) set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") elseif (FPHSA_HANDLE_VERSION_RANGE AND ${_NAME}_FIND_VERSION_RANGE) set(VERSION_MSG "(Required is version range \"${${_NAME}_FIND_VERSION_RANGE}\")") else() set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") endif() endif() else () # Check with DEFINED as the found version may be 0. if(DEFINED ${FPHSA_VERSION_VAR}) set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")") endif() endif () if(VERSION_OK) string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]") else() set(${_NAME}_FOUND FALSE) endif() # print the result: if (${_NAME}_FOUND) FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") else () if(FPHSA_CONFIG_MODE) _FPHSA_HANDLE_FAILURE_CONFIG_MODE() else() if(NOT VERSION_OK) set(RESULT_MSG) if (_FIRST_REQUIRED_VAR) string (APPEND RESULT_MSG "found ${${_FIRST_REQUIRED_VAR}}") endif() if (COMPONENT_MSG) if (RESULT_MSG) string (APPEND RESULT_MSG ", ") endif() string (APPEND RESULT_MSG "${FOUND_COMPONENTS_MSG}") endif() _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (${RESULT_MSG})") else() _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}") endif() endif() endif () set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) endfunction() cmake_policy(POP) kvproto-6.1.0-alpha/cpp/cmake/Modules/FindPackageMessage.cmake000066400000000000000000000032571421456440000242310ustar00rootroot00000000000000# Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. #[=======================================================================[.rst: FindPackageMessage ------------------ .. code-block:: cmake find_package_message( "message for user" "find result details") This function is intended to be used in FindXXX.cmake modules files. It will print a message once for each unique find result. This is useful for telling the user where a package was found. The first argument specifies the name (XXX) of the package. The second argument specifies the message to display. The third argument lists details about the find result so that if they change the message will be displayed again. The macro also obeys the QUIET argument to the find_package command. Example: .. code-block:: cmake if(X11_FOUND) find_package_message(X11 "Found X11: ${X11_X11_LIB}" "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]") else() ... endif() #]=======================================================================] function(find_package_message pkg msg details) # Avoid printing a message repeatedly for the same find result. if(NOT ${pkg}_FIND_QUIETLY) string(REPLACE "\n" "" details "${details}") set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") # The message has not yet been printed. message(STATUS "${msg}") # Save the find details in the cache to avoid printing the same # message again. set("${DETAILS_VAR}" "${details}" CACHE INTERNAL "Details about finding ${pkg}") endif() endif() endfunction() kvproto-6.1.0-alpha/cpp/cmake/Modules/FindgRPC.cmake000066400000000000000000000312131421456440000221550ustar00rootroot00000000000000#[[ Defines the following variables: ``gRPC_FOUND`` Whether the gRPC framework is found ``gRPC_INCLUDE_DIRS`` The include directories of the gRPC framework, including the include directories of the C++ wrapper. ``gRPC_LIBRARIES`` The libraries of the gRPC framework. ``gRPC_CPP_PLUGIN`` The plugin for generating gRPC client and server C++ stubs from `.proto` files ``gRPC_PYTHON_PLUGIN`` The plugin for generating gRPC client and server Python stubs from `.proto` files The following :prop_tgt:`IMPORTED` targets are also defined: ``grpc++`` ``grpc++_unsecure`` ``grpc_cpp_plugin`` ``grpc_python_plugin`` Set the following variables to adjust the behaviour of this script: ``gRPC_USE_UNSECURE_LIBRARIES`` if set gRPC_LIBRARIES will be filled with the unsecure version of the libraries (i.e. without SSL) instead of the secure ones. ``gRPC_DEBUG` if set the debug message will be printed. Add custom commands to process ``.proto`` files to C++:: protobuf_generate_grpc_cpp( [DESCRIPTORS ] [EXPORT_MACRO ] [...]) ``SRCS`` Variable to define with autogenerated source files ``HDRS`` Variable to define with autogenerated header files ``DESCRIPTORS`` Variable to define with autogenerated descriptor files, if requested. ``EXPORT_MACRO`` is a macro which should expand to ``__declspec(dllexport)`` or ``__declspec(dllimport)`` depending on what is being compiled. ``ARGN`` ``.proto`` files #]] # Function to generate C++ files from .proto files. # This function is a modified version of the function PROTOBUF_GENERATE_CPP() copied from https://github.com/Kitware/CMake/blob/master/Modules/FindProtobuf.cmake. function(PROTOBUF_GENERATE_GRPC_CPP SRCS HDRS) cmake_parse_arguments(protobuf_generate_grpc_cpp "" "EXPORT_MACRO;DESCRIPTORS" "" ${ARGN}) set(_proto_files "${protobuf_generate_grpc_cpp_UNPARSED_ARGUMENTS}") if(NOT _proto_files) message(SEND_ERROR "Error: PROTOBUF_GENERATE_GRPC_CPP() called without any proto files") return() endif() if(PROTOBUF_GENERATE_GRPC_CPP_APPEND_PATH) set(_append_arg APPEND_PATH) endif() if(protobuf_generate_grpc_cpp_DESCRIPTORS) set(_descriptors DESCRIPTORS) endif() if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS) set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}") endif() if(DEFINED Protobuf_IMPORT_DIRS) set(_import_arg IMPORT_DIRS ${Protobuf_IMPORT_DIRS}) endif() set(_outvar) protobuf_generate_grpc(${_append_arg} ${_descriptors} LANGUAGE cpp EXPORT_MACRO ${protobuf_generate_cpp_EXPORT_MACRO} OUT_VAR _outvar ${_import_arg} PROTOS ${_proto_files}) set(${SRCS}) set(${HDRS}) if(protobuf_generate_grpc_cpp_DESCRIPTORS) set(${protobuf_generate_grpc_cpp_DESCRIPTORS}) endif() foreach(_file ${_outvar}) if(_file MATCHES "cc$") list(APPEND ${SRCS} ${_file}) elseif(_file MATCHES "desc$") list(APPEND ${protobuf_generate_grpc_cpp_DESCRIPTORS} ${_file}) else() list(APPEND ${HDRS} ${_file}) endif() endforeach() set(${SRCS} ${${SRCS}} PARENT_SCOPE) set(${HDRS} ${${HDRS}} PARENT_SCOPE) if(protobuf_generate_grpc_cpp_DESCRIPTORS) set(${protobuf_generate_grpc_cpp_DESCRIPTORS} "${${protobuf_generate_grpc_cpp_DESCRIPTORS}}" PARENT_SCOPE) endif() endfunction() # Helper function. # This function is a modified version of the function protobuf_generate() copied from https://github.com/Kitware/CMake/blob/master/Modules/FindProtobuf.cmake. function(protobuf_generate_grpc) set(_options APPEND_PATH DESCRIPTORS) set(_singleargs LANGUAGE OUT_VAR EXPORT_MACRO PROTOC_OUT_DIR) if(COMMAND target_sources) list(APPEND _singleargs TARGET) endif() set(_multiargs PROTOS IMPORT_DIRS GENERATE_EXTENSIONS) cmake_parse_arguments(protobuf_generate_grpc "${_options}" "${_singleargs}" "${_multiargs}" "${ARGN}") if(NOT protobuf_generate_grpc_PROTOS AND NOT protobuf_generate_grpc_TARGET) message(SEND_ERROR "Error: protobuf_generate_grpc called without any targets or source files") return() endif() if(NOT protobuf_generate_grpc_OUT_VAR AND NOT protobuf_generate_grpc_TARGET) message(SEND_ERROR "Error: protobuf_generate_grpc called without a target or output variable") return() endif() if(NOT protobuf_generate_grpc_LANGUAGE) set(protobuf_generate_grpc_LANGUAGE cpp) endif() string(TOLOWER ${protobuf_generate_grpc_LANGUAGE} protobuf_generate_grpc_LANGUAGE) if(NOT protobuf_generate_grpc_PROTOC_OUT_DIR) set(protobuf_generate_grpc_PROTOC_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR}) endif() if(protobuf_generate_grpc_EXPORT_MACRO AND protobuf_generate_grpc_LANGUAGE STREQUAL cpp) set(_dll_export_decl "dllexport_decl=${protobuf_generate_grpc_EXPORT_MACRO}:") endif() if(NOT protobuf_generate_grpc_GENERATE_EXTENSIONS) if(protobuf_generate_grpc_LANGUAGE STREQUAL cpp) set(protobuf_generate_grpc_GENERATE_EXTENSIONS .pb.h .pb.cc .grpc.pb.h .grpc.pb.cc) elseif(protobuf_generate_grpc_LANGUAGE STREQUAL python) set(protobuf_generate_grpc_GENERATE_EXTENSIONS _pb2.py) else() message(SEND_ERROR "Error: protobuf_generate_grpc given unknown Language ${LANGUAGE}, please provide a value for GENERATE_EXTENSIONS") return() endif() endif() if(NOT protobuf_generate_grpc_PLUGIN) if(protobuf_generate_grpc_LANGUAGE STREQUAL cpp) set(protobuf_generate_grpc_PLUGIN "grpc_cpp_plugin") elseif(protobuf_generate_grpc_LANGUAGE STREQUAL python) set(protobuf_generate_grpc_PLUGIN "grpc_python_plugin") else() message(SEND_ERROR "Error: protobuf_generate_grpc given unknown Language ${LANGUAGE}, please provide a value for PLUGIN") return() endif() endif() if(protobuf_generate_grpc_TARGET) get_target_property(_source_list ${protobuf_generate_grpc_TARGET} SOURCES) foreach(_file ${_source_list}) if(_file MATCHES "proto$") list(APPEND protobuf_generate_grpc_PROTOS ${_file}) endif() endforeach() endif() if(NOT protobuf_generate_grpc_PROTOS) message(SEND_ERROR "Error: protobuf_generate_grpc could not find any .proto files") return() endif() if(protobuf_generate_grpc_APPEND_PATH) # Create an include path for each file specified foreach(_file ${protobuf_generate_grpc_PROTOS}) get_filename_component(_abs_file ${_file} ABSOLUTE) get_filename_component(_abs_path ${_abs_file} PATH) list(FIND _protobuf_include_path ${_abs_path} _contains_already) if(${_contains_already} EQUAL -1) list(APPEND _protobuf_include_path -I ${_abs_path}) endif() endforeach() else() set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR}) endif() foreach(DIR ${protobuf_generate_grpc_IMPORT_DIRS}) get_filename_component(ABS_PATH ${DIR} ABSOLUTE) list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) if(${_contains_already} EQUAL -1) list(APPEND _protobuf_include_path -I ${ABS_PATH}) endif() endforeach() set(_generated_srcs_all) foreach(_proto ${protobuf_generate_grpc_PROTOS}) get_filename_component(_abs_file ${_proto} ABSOLUTE) get_filename_component(_abs_dir ${_abs_file} DIRECTORY) get_filename_component(_basename ${_proto} NAME_WE) file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir}) set(_possible_rel_dir) if(NOT protobuf_generate_grpc_APPEND_PATH) set(_possible_rel_dir ${_rel_dir}/) endif() set(_generated_srcs) foreach(_ext ${protobuf_generate_grpc_GENERATE_EXTENSIONS}) list(APPEND _generated_srcs "${protobuf_generate_grpc_PROTOC_OUT_DIR}/${_possible_rel_dir}${_basename}${_ext}") endforeach() if(protobuf_generate_grpc_DESCRIPTORS AND protobuf_generate_grpc_LANGUAGE STREQUAL cpp) set(_descriptor_file "${CMAKE_CURRENT_BINARY_DIR}/${_basename}.desc") set(_dll_desc_out "--descriptor_set_out=${_descriptor_file}") list(APPEND _generated_srcs ${_descriptor_file}) endif() list(APPEND _generated_srcs_all ${_generated_srcs}) add_custom_command( OUTPUT ${_generated_srcs} COMMAND protobuf::protoc ARGS --${protobuf_generate_grpc_LANGUAGE}_out ${_dll_export_decl}${protobuf_generate_grpc_PROTOC_OUT_DIR} --grpc_out ${_dll_export_decl}${protobuf_generate_grpc_PROTOC_OUT_DIR} --plugin=protoc-gen-grpc=$ ${_dll_desc_out} ${_protobuf_include_path} ${_abs_file} DEPENDS ${_abs_file} protobuf::protoc ${protobuf_generate_grpc_PLUGIN} COMMENT "Running ${protobuf_generate_grpc_LANGUAGE} protocol buffer compiler on ${_proto}" VERBATIM) endforeach() set_source_files_properties(${_generated_srcs_all} PROPERTIES GENERATED TRUE) if(protobuf_generate_grpc_OUT_VAR) set(${protobuf_generate_grpc_OUT_VAR} ${_generated_srcs_all} PARENT_SCOPE) endif() if(protobuf_generate_grpc_TARGET) target_sources(${protobuf_generate_grpc_TARGET} PRIVATE ${_generated_srcs_all}) endif() endfunction() # Find the libraries. if(gRPC_USE_STATIC_LIBS) # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES set(_gRPC_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) if(WIN32) set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) else() set(CMAKE_FIND_LIBRARY_SUFFIXES .a) endif() endif() find_library(gRPC_LIBRARY NAMES grpc) find_library(gRPC_CPP_LIBRARY NAMES grpc++) find_library(gRPC_UNSECURE_LIBRARY NAMES grpc_unsecure) find_library(gRPC_CPP_UNSECURE_LIBRARY NAMES grpc++_unsecure) find_library(gRPC_CARES_LIBRARY NAMES cares) set(gRPC_LIBRARIES) if(gRPC_USE_UNSECURE_LIBRARIES) if(gRPC_UNSECURE_LIBRARY) set(gRPC_LIBRARIES ${gRPC_LIBRARIES} ${gRPC_UNSECURE_LIBRARY}) endif() if(gRPC_CPP_UNSECURE_LIBRARY) set(gRPC_LIBRARIES ${gRPC_LIBRARIES} ${gRPC_CPP_UNSECURE_LIBRARY}) endif() else() if(gRPC_LIBRARY) set(gRPC_LIBRARIES ${gRPC_LIBRARIES} ${gRPC_LIBRARY}) endif() if(gRPC_CPP_UNSECURE_LIBRARY) set(gRPC_LIBRARIES ${gRPC_LIBRARIES} ${gRPC_CPP_LIBRARY}) endif() endif() set(gRPC_LIBRARIES ${gRPC_LIBRARIES} ${gRPC_CARES_LIBRARY}) # Restore the original find library ordering. if(gRPC_USE_STATIC_LIBS) set(CMAKE_FIND_LIBRARY_SUFFIXES ${_gRPC_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) endif() # Find the include directories. find_path(gRPC_INCLUDE_DIR grpc/grpc.h) find_path(gRPC_CPP_INCLUDE_DIR grpc++/grpc++.h) if(gRPC_INCLUDE_DIR AND gRPC_CPP_INCLUDE_DIR AND NOT(gRPC_INCLUDE_DIR STREQUAL gRPC_CPP_INCLUDE_DIR)) set(gRPC_INCLUDE_DIRS ${gRPC_INCLUDE_DIR} ${gRPC_CPP_INCLUDE_DIR}) elseif(gRPC_INCLUDE_DIR) set(gRPC_INCLUDE_DIRS ${gRPC_INCLUDE_DIR}) else() set(gRPC_INCLUDE_DIRS ${gRPC_CPP_INCLUDE_DIR}) endif() # Get full path to plugin. find_program(gRPC_CPP_PLUGIN NAMES grpc_cpp_plugin DOC "The plugin for generating gRPC client and server C++ stubs from `.proto` files") find_program(gRPC_PYTHON_PLUGIN NAMES grpc_python_plugin DOC "The plugin for generating gRPC client and server Python stubs from `.proto` files") # Add imported targets. if(gRPC_CPP_LIBRARY AND NOT TARGET grpc++) add_library(grpc++ UNKNOWN IMPORTED) set_target_properties(grpc++ PROPERTIES IMPORTED_LOCATION "${gRPC_CPP_LIBRARY}") set_target_properties(grpc++ PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${gRPC_INCLUDE_DIRS}) endif() if(gRPC_CPP_UNSECURE_LIBRARY AND NOT TARGET grpc++_unsecure) add_library(grpc++_unsecure UNKNOWN IMPORTED) set_target_properties(grpc++_unsecure PROPERTIES IMPORTED_LOCATION "${gRPC_CPP_UNSECURE_LIBRARY}") set_target_properties(grpc++_unsecure PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${gRPC_INCLUDE_DIRS}) endif() if(gRPC_CPP_PLUGIN AND NOT TARGET grpc_cpp_plugin) add_executable(grpc_cpp_plugin IMPORTED) set_target_properties(grpc_cpp_plugin PROPERTIES IMPORTED_LOCATION "${gRPC_CPP_PLUGIN}") endif() if(gRPC_PYTHON_PLUGIN AND NOT TARGET grpc_python_plugin) add_executable(grpc_python_plugin IMPORTED) set_target_properties(grpc_python_plugin PROPERTIES IMPORTED_LOCATION "${gRPC_PYTHON_PLUGIN}") endif() include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(gRPC REQUIRED_VARS gRPC_LIBRARY gRPC_CPP_LIBRARY gRPC_UNSECURE_LIBRARY gRPC_CPP_UNSECURE_LIBRARY gRPC_CARES_LIBRARY gRPC_INCLUDE_DIR gRPC_CPP_INCLUDE_DIR gRPC_CPP_PLUGIN gRPC_PYTHON_PLUGIN) if(gRPC_FOUND) if(gRPC_DEBUG) message(STATUS "gRPC: INCLUDE_DIRS=${gRPC_INCLUDE_DIRS}") message(STATUS "gRPC: LIBRARIES=${gRPC_LIBRARIES}") message(STATUS "gRPC: CPP_PLUGIN=${gRPC_CPP_PLUGIN}") message(STATUS "gRPC: PYTHON_PLUGIN=${gRPC_PYTHON_PLUGIN}") endif() endif() kvproto-6.1.0-alpha/cpp/cmake/find_grpc.cmake000066400000000000000000000002101421456440000210750ustar00rootroot00000000000000find_package(gRPC REQUIRED) message(STATUS "Using gRPC: ${gRPC_VERSION} : ${gRPC_INCLUDE_DIRS}, ${gRPC_LIBRARIES}, ${gRPC_CPP_PLUGIN}") kvproto-6.1.0-alpha/cpp/cmake/find_protobuf.cmake000066400000000000000000000002441421456440000220110ustar00rootroot00000000000000find_package(Protobuf REQUIRED) message(STATUS "Using protobuf: ${Protobuf_VERSION} : ${Protobuf_INCLUDE_DIR}, ${Protobuf_LIBRARY}, ${Protobuf_PROTOC_EXECUTABLE}") kvproto-6.1.0-alpha/go.mod000066400000000000000000000005001421456440000154060ustar00rootroot00000000000000module github.com/pingcap/kvproto require ( github.com/gogo/protobuf v1.3.1 github.com/golang/protobuf v1.3.2 github.com/grpc-ecosystem/grpc-gateway v1.12.1 golang.org/x/net v0.0.0-20191002035440-2ec189313ef0 google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c google.golang.org/grpc v1.24.0 ) go 1.13 kvproto-6.1.0-alpha/go.sum000066400000000000000000000126571421456440000154530ustar00rootroot00000000000000cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6/go.mod h1:V8iCPQYkqmusNa815XgQio277wI47sdRh1dUOLdyC6Q= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/grpc-ecosystem/grpc-gateway v1.12.1 h1:zCy2xE9ablevUOrUZc3Dl72Dt+ya2FNAvC2yLYMHzi4= github.com/grpc-ecosystem/grpc-gateway v1.12.1/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c= github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20191002035440-2ec189313ef0 h1:2mqDk8w/o6UmeUCu5Qiq2y7iMf6anbx+YA8d1JFoFrs= golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c h1:hrpEMCZ2O7DR5gC1n2AJGVhrwiEjOi35+jxtIuZpTMo= google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.24.0 h1:vb/1TCsVn3DcJlQ0Gs1yB1pKI6Do2/QNwxdKqmc/b0s= google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= kvproto-6.1.0-alpha/include/000077500000000000000000000000001421456440000157305ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/eraftpb.proto000066400000000000000000000140651421456440000204460ustar00rootroot00000000000000syntax = "proto3"; package eraftpb; enum EntryType { EntryNormal = 0; EntryConfChange = 1; EntryConfChangeV2 = 2; } // The entry is a type of change that needs to be applied. It contains two data fields. // While the fields are built into the model; their usage is determined by the entry_type. // // For normal entries, the data field should contain the data change that should be applied. // The context field can be used for any contextual data that might be relevant to the // application of the data. // // For configuration changes, the data will contain the ConfChange message and the // context will provide anything needed to assist the configuration change. The context // if for the user to set and use in this case. message Entry { EntryType entry_type = 1; uint64 term = 2; uint64 index = 3; bytes data = 4; bytes context = 6; // Deprecated! It is kept for backward compatibility. // TODO: remove it in the next major release. bool sync_log = 5; } message SnapshotMetadata { // The current `ConfState`. ConfState conf_state = 1; // The applied index. uint64 index = 2; // The term of the applied index. uint64 term = 3; } message Snapshot { bytes data = 1; SnapshotMetadata metadata = 2; } enum MessageType { MsgHup = 0; MsgBeat = 1; MsgPropose = 2; MsgAppend = 3; MsgAppendResponse = 4; MsgRequestVote = 5; MsgRequestVoteResponse = 6; MsgSnapshot = 7; MsgHeartbeat = 8; MsgHeartbeatResponse = 9; MsgUnreachable = 10; MsgSnapStatus = 11; MsgCheckQuorum = 12; MsgTransferLeader = 13; MsgTimeoutNow = 14; MsgReadIndex = 15; MsgReadIndexResp = 16; MsgRequestPreVote = 17; MsgRequestPreVoteResponse = 18; } message Message { MessageType msg_type = 1; uint64 to = 2; uint64 from = 3; uint64 term = 4; uint64 log_term = 5; uint64 index = 6; repeated Entry entries = 7; uint64 commit = 8; Snapshot snapshot = 9; uint64 request_snapshot = 13; bool reject = 10; uint64 reject_hint = 11; bytes context = 12; uint64 priority = 14; } message HardState { uint64 term = 1; uint64 vote = 2; uint64 commit = 3; } enum ConfChangeTransition { // Automatically use the simple protocol if possible, otherwise fall back // to ConfChangeType::Implicit. Most applications will want to use this. Auto = 0; // Use joint consensus unconditionally, and transition out of them // automatically (by proposing a zero configuration change). // // This option is suitable for applications that want to minimize the time // spent in the joint configuration and do not store the joint configuration // in the state machine (outside of InitialState). Implicit = 1; // Use joint consensus and remain in the joint configuration until the // application proposes a no-op configuration change. This is suitable for // applications that want to explicitly control the transitions, for example // to use a custom payload (via the Context field). Explicit = 2; } message ConfState { repeated uint64 voters = 1; repeated uint64 learners = 2; // The voters in the outgoing config. If not empty the node is in joint consensus. repeated uint64 voters_outgoing = 3; // The nodes that will become learners when the outgoing config is removed. // These nodes are necessarily currently in nodes_joint (or they would have // been added to the incoming config right away). repeated uint64 learners_next = 4; // If set, the config is joint and Raft will automatically transition into // the final config (i.e. remove the outgoing config) when this is safe. bool auto_leave = 5; } enum ConfChangeType { AddNode = 0; RemoveNode = 1; AddLearnerNode = 2; } message ConfChange { ConfChangeType change_type = 2; uint64 node_id = 3; bytes context = 4; uint64 id = 1; } // ConfChangeSingle is an individual configuration change operation. Multiple // such operations can be carried out atomically via a ConfChangeV2. message ConfChangeSingle { ConfChangeType change_type = 1; uint64 node_id = 2; } // ConfChangeV2 messages initiate configuration changes. They support both the // simple "one at a time" membership change protocol and full Joint Consensus // allowing for arbitrary changes in membership. // // The supplied context is treated as an opaque payload and can be used to // attach an action on the state machine to the application of the config change // proposal. Note that contrary to Joint Consensus as outlined in the Raft // paper[1], configuration changes become active when they are *applied* to the // state machine (not when they are appended to the log). // // The simple protocol can be used whenever only a single change is made. // // Non-simple changes require the use of Joint Consensus, for which two // configuration changes are run. The first configuration change specifies the // desired changes and transitions the Raft group into the joint configuration, // in which quorum requires a majority of both the pre-changes and post-changes // configuration. Joint Consensus avoids entering fragile intermediate // configurations that could compromise survivability. For example, without the // use of Joint Consensus and running across three availability zones with a // replication factor of three, it is not possible to replace a voter without // entering an intermediate configuration that does not survive the outage of // one availability zone. // // The provided ConfChangeTransition specifies how (and whether) Joint Consensus // is used, and assigns the task of leaving the joint configuration either to // Raft or the application. Leaving the joint configuration is accomplished by // proposing a ConfChangeV2 with only and optionally the Context field // populated. // // For details on Raft membership changes, see: // // [1]: https://github.com/ongardie/dissertation/blob/master/online-trim.pdf message ConfChangeV2 { ConfChangeTransition transition = 1; repeated ConfChangeSingle changes = 2; bytes context = 3; } kvproto-6.1.0-alpha/include/gogoproto/000077500000000000000000000000001421456440000177475ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/gogoproto/gogo.proto000066400000000000000000000110151421456440000217650ustar00rootroot00000000000000// Protocol Buffers for Go with Gadgets // // Copyright (c) 2013, The GoGo Authors. All rights reserved. // http://github.com/gogo/protobuf // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto2"; package gogoproto; import "google/protobuf/descriptor.proto"; option java_package = "com.google.protobuf"; option java_outer_classname = "GoGoProtos"; option go_package = "github.com/gogo/protobuf/gogoproto"; extend google.protobuf.EnumOptions { optional bool goproto_enum_prefix = 62001; optional bool goproto_enum_stringer = 62021; optional bool enum_stringer = 62022; optional string enum_customname = 62023; optional bool enumdecl = 62024; } extend google.protobuf.EnumValueOptions { optional string enumvalue_customname = 66001; } extend google.protobuf.FileOptions { optional bool goproto_getters_all = 63001; optional bool goproto_enum_prefix_all = 63002; optional bool goproto_stringer_all = 63003; optional bool verbose_equal_all = 63004; optional bool face_all = 63005; optional bool gostring_all = 63006; optional bool populate_all = 63007; optional bool stringer_all = 63008; optional bool onlyone_all = 63009; optional bool equal_all = 63013; optional bool description_all = 63014; optional bool testgen_all = 63015; optional bool benchgen_all = 63016; optional bool marshaler_all = 63017; optional bool unmarshaler_all = 63018; optional bool stable_marshaler_all = 63019; optional bool sizer_all = 63020; optional bool goproto_enum_stringer_all = 63021; optional bool enum_stringer_all = 63022; optional bool unsafe_marshaler_all = 63023; optional bool unsafe_unmarshaler_all = 63024; optional bool goproto_extensions_map_all = 63025; optional bool goproto_unrecognized_all = 63026; optional bool gogoproto_import = 63027; optional bool protosizer_all = 63028; optional bool compare_all = 63029; optional bool typedecl_all = 63030; optional bool enumdecl_all = 63031; optional bool goproto_registration = 63032; optional bool messagename_all = 63033; } extend google.protobuf.MessageOptions { optional bool goproto_getters = 64001; optional bool goproto_stringer = 64003; optional bool verbose_equal = 64004; optional bool face = 64005; optional bool gostring = 64006; optional bool populate = 64007; optional bool stringer = 67008; optional bool onlyone = 64009; optional bool equal = 64013; optional bool description = 64014; optional bool testgen = 64015; optional bool benchgen = 64016; optional bool marshaler = 64017; optional bool unmarshaler = 64018; optional bool stable_marshaler = 64019; optional bool sizer = 64020; optional bool unsafe_marshaler = 64023; optional bool unsafe_unmarshaler = 64024; optional bool goproto_extensions_map = 64025; optional bool goproto_unrecognized = 64026; optional bool protosizer = 64028; optional bool compare = 64029; optional bool typedecl = 64030; optional bool messagename = 64033; } extend google.protobuf.FieldOptions { optional bool nullable = 65001; optional bool embed = 65002; optional string customtype = 65003; optional string customname = 65004; optional string jsontag = 65005; optional string moretags = 65006; optional string casttype = 65007; optional string castkey = 65008; optional string castvalue = 65009; optional bool stdtime = 65010; optional bool stdduration = 65011; } kvproto-6.1.0-alpha/include/google/000077500000000000000000000000001421456440000172045ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/google/api/000077500000000000000000000000001421456440000177555ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/google/api/annotations.proto000066400000000000000000000020331421456440000233750ustar00rootroot00000000000000// Copyright (c) 2015, Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. syntax = "proto3"; package google.api; import "google/api/http.proto"; import "google/protobuf/descriptor.proto"; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "AnnotationsProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; extend google.protobuf.MethodOptions { // See `HttpRule`. HttpRule http = 72295728; } kvproto-6.1.0-alpha/include/google/api/http.proto000066400000000000000000000354501421456440000220300ustar00rootroot00000000000000// Copyright 2019 Google LLC. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // syntax = "proto3"; package google.api; option cc_enable_arenas = true; option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; option java_multiple_files = true; option java_outer_classname = "HttpProto"; option java_package = "com.google.api"; option objc_class_prefix = "GAPI"; // Defines the HTTP configuration for an API service. It contains a list of // [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method // to one or more HTTP REST API methods. message Http { // A list of HTTP configuration rules that apply to individual API methods. // // **NOTE:** All service configuration rules follow "last one wins" order. repeated HttpRule rules = 1; // When set to true, URL path parameters will be fully URI-decoded except in // cases of single segment matches in reserved expansion, where "%2F" will be // left encoded. // // The default behavior is to not decode RFC 6570 reserved characters in multi // segment matches. bool fully_decode_reserved_expansion = 2; } // # gRPC Transcoding // // gRPC Transcoding is a feature for mapping between a gRPC method and one or // more HTTP REST endpoints. It allows developers to build a single API service // that supports both gRPC APIs and REST APIs. Many systems, including [Google // APIs](https://github.com/googleapis/googleapis), // [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC // Gateway](https://github.com/grpc-ecosystem/grpc-gateway), // and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature // and use it for large scale production services. // // `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies // how different portions of the gRPC request message are mapped to the URL // path, URL query parameters, and HTTP request body. It also controls how the // gRPC response message is mapped to the HTTP response body. `HttpRule` is // typically specified as an `google.api.http` annotation on the gRPC method. // // Each mapping specifies a URL path template and an HTTP method. The path // template may refer to one or more fields in the gRPC request message, as long // as each field is a non-repeated field with a primitive (non-message) type. // The path template controls how fields of the request message are mapped to // the URL path. // // Example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get: "/v1/{name=messages/*}" // }; // } // } // message GetMessageRequest { // string name = 1; // Mapped to URL path. // } // message Message { // string text = 1; // The resource content. // } // // This enables an HTTP REST to gRPC mapping as below: // // HTTP | gRPC // -----|----- // `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` // // Any fields in the request message which are not bound by the path template // automatically become HTTP query parameters if there is no HTTP request body. // For example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get:"/v1/messages/{message_id}" // }; // } // } // message GetMessageRequest { // message SubMessage { // string subfield = 1; // } // string message_id = 1; // Mapped to URL path. // int64 revision = 2; // Mapped to URL query parameter `revision`. // SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. // } // // This enables a HTTP JSON to RPC mapping as below: // // HTTP | gRPC // -----|----- // `GET /v1/messages/123456?revision=2&sub.subfield=foo` | // `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: // "foo"))` // // Note that fields which are mapped to URL query parameters must have a // primitive type or a repeated primitive type or a non-repeated message type. // In the case of a repeated type, the parameter can be repeated in the URL // as `...?param=A¶m=B`. In the case of a message type, each field of the // message is mapped to a separate parameter, such as // `...?foo.a=A&foo.b=B&foo.c=C`. // // For HTTP methods that allow a request body, the `body` field // specifies the mapping. Consider a REST update method on the // message resource collection: // // service Messaging { // rpc UpdateMessage(UpdateMessageRequest) returns (Message) { // option (google.api.http) = { // patch: "/v1/messages/{message_id}" // body: "message" // }; // } // } // message UpdateMessageRequest { // string message_id = 1; // mapped to the URL // Message message = 2; // mapped to the body // } // // The following HTTP JSON to RPC mapping is enabled, where the // representation of the JSON in the request body is determined by // protos JSON encoding: // // HTTP | gRPC // -----|----- // `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: // "123456" message { text: "Hi!" })` // // The special name `*` can be used in the body mapping to define that // every field not bound by the path template should be mapped to the // request body. This enables the following alternative definition of // the update method: // // service Messaging { // rpc UpdateMessage(Message) returns (Message) { // option (google.api.http) = { // patch: "/v1/messages/{message_id}" // body: "*" // }; // } // } // message Message { // string message_id = 1; // string text = 2; // } // // // The following HTTP JSON to RPC mapping is enabled: // // HTTP | gRPC // -----|----- // `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: // "123456" text: "Hi!")` // // Note that when using `*` in the body mapping, it is not possible to // have HTTP parameters, as all fields not bound by the path end in // the body. This makes this option more rarely used in practice when // defining REST APIs. The common usage of `*` is in custom methods // which don't use the URL at all for transferring data. // // It is possible to define multiple HTTP methods for one RPC by using // the `additional_bindings` option. Example: // // service Messaging { // rpc GetMessage(GetMessageRequest) returns (Message) { // option (google.api.http) = { // get: "/v1/messages/{message_id}" // additional_bindings { // get: "/v1/users/{user_id}/messages/{message_id}" // } // }; // } // } // message GetMessageRequest { // string message_id = 1; // string user_id = 2; // } // // This enables the following two alternative HTTP JSON to RPC mappings: // // HTTP | gRPC // -----|----- // `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` // `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: // "123456")` // // ## Rules for HTTP mapping // // 1. Leaf request fields (recursive expansion nested messages in the request // message) are classified into three categories: // - Fields referred by the path template. They are passed via the URL path. // - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They are passed via the HTTP // request body. // - All other fields are passed via the URL query parameters, and the // parameter name is the field path in the request message. A repeated // field can be represented as multiple query parameters under the same // name. // 2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL query parameter, all fields // are passed via URL path and HTTP request body. // 3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP request body, all // fields are passed via URL path and URL query parameters. // // ### Path template syntax // // Template = "/" Segments [ Verb ] ; // Segments = Segment { "/" Segment } ; // Segment = "*" | "**" | LITERAL | Variable ; // Variable = "{" FieldPath [ "=" Segments ] "}" ; // FieldPath = IDENT { "." IDENT } ; // Verb = ":" LITERAL ; // // The syntax `*` matches a single URL path segment. The syntax `**` matches // zero or more URL path segments, which must be the last part of the URL path // except the `Verb`. // // The syntax `Variable` matches part of the URL path as specified by its // template. A variable template must not contain other variables. If a variable // matches a single path segment, its template may be omitted, e.g. `{var}` // is equivalent to `{var=*}`. // // The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` // contains any reserved character, such characters should be percent-encoded // before the matching. // // If a variable contains exactly one path segment, such as `"{var}"` or // `"{var=*}"`, when such a variable is expanded into a URL path on the client // side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The // server side does the reverse decoding. Such variables show up in the // [Discovery // Document](https://developers.google.com/discovery/v1/reference/apis) as // `{var}`. // // If a variable contains multiple path segments, such as `"{var=foo/*}"` // or `"{var=**}"`, when such a variable is expanded into a URL path on the // client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. // The server side does the reverse decoding, except "%2F" and "%2f" are left // unchanged. Such variables show up in the // [Discovery // Document](https://developers.google.com/discovery/v1/reference/apis) as // `{+var}`. // // ## Using gRPC API Service Configuration // // gRPC API Service Configuration (service config) is a configuration language // for configuring a gRPC service to become a user-facing product. The // service config is simply the YAML representation of the `google.api.Service` // proto message. // // As an alternative to annotating your proto file, you can configure gRPC // transcoding in your service config YAML files. You do this by specifying a // `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same // effect as the proto annotation. This can be particularly useful if you // have a proto that is reused in multiple services. Note that any transcoding // specified in the service config will override any matching transcoding // configuration in the proto. // // Example: // // http: // rules: // # Selects a gRPC method and applies HttpRule to it. // - selector: example.v1.Messaging.GetMessage // get: /v1/messages/{message_id}/{sub.subfield} // // ## Special notes // // When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the // proto to JSON conversion must follow the [proto3 // specification](https://developers.google.com/protocol-buffers/docs/proto3#json). // // While the single segment variable follows the semantics of // [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String // Expansion, the multi segment variable **does not** follow RFC 6570 Section // 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion // does not expand special characters like `?` and `#`, which would lead // to invalid URLs. As the result, gRPC Transcoding uses a custom encoding // for multi segment variables. // // The path variables **must not** refer to any repeated or mapped field, // because client libraries are not capable of handling such variable expansion. // // The path variables **must not** capture the leading "/" character. The reason // is that the most common use case "{var}" does not capture the leading "/" // character. For consistency, all path variables must share the same behavior. // // Repeated message fields must not be mapped to URL query parameters, because // no client library can support such complicated mapping. // // If an API needs to use a JSON array for request or response body, it can map // the request or response body to a repeated field. However, some gRPC // Transcoding implementations may not support this feature. message HttpRule { // Selects a method to which this rule applies. // // Refer to [selector][google.api.DocumentationRule.selector] for syntax details. string selector = 1; // Determines the URL pattern is matched by this rules. This pattern can be // used with any of the {get|put|post|delete|patch} methods. A custom method // can be defined using the 'custom' field. oneof pattern { // Maps to HTTP GET. Used for listing and getting information about // resources. string get = 2; // Maps to HTTP PUT. Used for replacing a resource. string put = 3; // Maps to HTTP POST. Used for creating a resource or performing an action. string post = 4; // Maps to HTTP DELETE. Used for deleting a resource. string delete = 5; // Maps to HTTP PATCH. Used for updating a resource. string patch = 6; // The custom pattern is used for specifying an HTTP method that is not // included in the `pattern` field, such as HEAD, or "*" to leave the // HTTP method unspecified for this rule. The wild-card rule is useful // for services that provide content to Web (HTML) clients. CustomHttpPattern custom = 8; } // The name of the request field whose value is mapped to the HTTP request // body, or `*` for mapping all request fields not captured by the path // pattern to the HTTP body, or omitted for not having any HTTP request body. // // NOTE: the referred field must be present at the top-level of the request // message type. string body = 7; // Optional. The name of the response field whose value is mapped to the HTTP // response body. When omitted, the entire response message will be used // as the HTTP response body. // // NOTE: The referred field must be present at the top-level of the response // message type. string response_body = 12; // Additional HTTP bindings for the selector. Nested bindings must // not contain an `additional_bindings` field themselves (that is, // the nesting may only be one level deep). repeated HttpRule additional_bindings = 11; } // A custom pattern is used for defining custom HTTP verb. message CustomHttpPattern { // The name of this custom HTTP verb. string kind = 1; // The path matched by this custom verb. string path = 2; } kvproto-6.1.0-alpha/include/google/protobuf/000077500000000000000000000000001421456440000210445ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/google/protobuf/any.proto000066400000000000000000000132341421456440000227230ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "AnyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; // `Any` contains an arbitrary serialized protocol buffer message along with a // URL that describes the type of the serialized message. // // Protobuf library provides support to pack/unpack Any values in the form // of utility functions or additional generated methods of the Any type. // // Example 1: Pack and unpack a message in C++. // // Foo foo = ...; // Any any; // any.PackFrom(foo); // ... // if (any.UnpackTo(&foo)) { // ... // } // // Example 2: Pack and unpack a message in Java. // // Foo foo = ...; // Any any = Any.pack(foo); // ... // if (any.is(Foo.class)) { // foo = any.unpack(Foo.class); // } // // Example 3: Pack and unpack a message in Python. // // foo = Foo(...) // any = Any() // any.Pack(foo) // ... // if any.Is(Foo.DESCRIPTOR): // any.Unpack(foo) // ... // // Example 4: Pack and unpack a message in Go // // foo := &pb.Foo{...} // any, err := ptypes.MarshalAny(foo) // ... // foo := &pb.Foo{} // if err := ptypes.UnmarshalAny(any, foo); err != nil { // ... // } // // The pack methods provided by protobuf library will by default use // 'type.googleapis.com/full.type.name' as the type URL and the unpack // methods only use the fully qualified type name after the last '/' // in the type URL, for example "foo.bar.com/x/y.z" will yield type // name "y.z". // // // JSON // ==== // The JSON representation of an `Any` value uses the regular // representation of the deserialized, embedded message, with an // additional field `@type` which contains the type URL. Example: // // package google.profile; // message Person { // string first_name = 1; // string last_name = 2; // } // // { // "@type": "type.googleapis.com/google.profile.Person", // "firstName": , // "lastName": // } // // If the embedded message type is well-known and has a custom JSON // representation, that representation will be embedded adding a field // `value` which holds the custom JSON in addition to the `@type` // field. Example (for message [google.protobuf.Duration][]): // // { // "@type": "type.googleapis.com/google.protobuf.Duration", // "value": "1.212s" // } // message Any { // A URL/resource name that uniquely identifies the type of the serialized // protocol buffer message. The last segment of the URL's path must represent // the fully qualified name of the type (as in // `path/google.protobuf.Duration`). The name should be in a canonical form // (e.g., leading "." is not accepted). // // In practice, teams usually precompile into the binary all types that they // expect it to use in the context of Any. However, for URLs which use the // scheme `http`, `https`, or no scheme, one can optionally set up a type // server that maps type URLs to message definitions as follows: // // * If no scheme is provided, `https` is assumed. // * An HTTP GET on the URL must yield a [google.protobuf.Type][] // value in binary format, or produce an error. // * Applications are allowed to cache lookup results based on the // URL, or have them precompiled into a binary to avoid any // lookup. Therefore, binary compatibility needs to be preserved // on changes to types. (Use versioned type names to manage // breaking changes.) // // Note: this functionality is not currently available in the official // protobuf release, and it is not used for type URLs beginning with // type.googleapis.com. // // Schemes other than `http`, `https` (or the empty scheme) might be // used with implementation specific semantics. // string type_url = 1; // Must be a valid serialized protocol buffer of the above specified type. bytes value = 2; } kvproto-6.1.0-alpha/include/google/protobuf/api.proto000066400000000000000000000170201421456440000227020ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; import "google/protobuf/source_context.proto"; import "google/protobuf/type.proto"; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "ApiProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; option go_package = "types"; // Api is a light-weight descriptor for an API Interface. // // Interfaces are also described as "protocol buffer services" in some contexts, // such as by the "service" keyword in a .proto file, but they are different // from API Services, which represent a concrete implementation of an interface // as opposed to simply a description of methods and bindings. They are also // sometimes simply referred to as "APIs" in other contexts, such as the name of // this message itself. See https://cloud.google.com/apis/design/glossary for // detailed terminology. message Api { // The fully qualified name of this interface, including package name // followed by the interface's simple name. string name = 1; // The methods of this interface, in unspecified order. repeated Method methods = 2; // Any metadata attached to the interface. repeated Option options = 3; // A version string for this interface. If specified, must have the form // `major-version.minor-version`, as in `1.10`. If the minor version is // omitted, it defaults to zero. If the entire version field is empty, the // major version is derived from the package name, as outlined below. If the // field is not empty, the version in the package name will be verified to be // consistent with what is provided here. // // The versioning schema uses [semantic // versioning](http://semver.org) where the major version number // indicates a breaking change and the minor version an additive, // non-breaking change. Both version numbers are signals to users // what to expect from different versions, and should be carefully // chosen based on the product plan. // // The major version is also reflected in the package name of the // interface, which must end in `v`, as in // `google.feature.v1`. For major versions 0 and 1, the suffix can // be omitted. Zero major versions must only be used for // experimental, non-GA interfaces. // // string version = 4; // Source context for the protocol buffer service represented by this // message. SourceContext source_context = 5; // Included interfaces. See [Mixin][]. repeated Mixin mixins = 6; // The source syntax of the service. Syntax syntax = 7; } // Method represents a method of an API interface. message Method { // The simple name of this method. string name = 1; // A URL of the input message type. string request_type_url = 2; // If true, the request is streamed. bool request_streaming = 3; // The URL of the output message type. string response_type_url = 4; // If true, the response is streamed. bool response_streaming = 5; // Any metadata attached to the method. repeated Option options = 6; // The source syntax of this method. Syntax syntax = 7; } // Declares an API Interface to be included in this interface. The including // interface must redeclare all the methods from the included interface, but // documentation and options are inherited as follows: // // - If after comment and whitespace stripping, the documentation // string of the redeclared method is empty, it will be inherited // from the original method. // // - Each annotation belonging to the service config (http, // visibility) which is not set in the redeclared method will be // inherited. // // - If an http annotation is inherited, the path pattern will be // modified as follows. Any version prefix will be replaced by the // version of the including interface plus the [root][] path if // specified. // // Example of a simple mixin: // // package google.acl.v1; // service AccessControl { // // Get the underlying ACL object. // rpc GetAcl(GetAclRequest) returns (Acl) { // option (google.api.http).get = "/v1/{resource=**}:getAcl"; // } // } // // package google.storage.v2; // service Storage { // rpc GetAcl(GetAclRequest) returns (Acl); // // // Get a data record. // rpc GetData(GetDataRequest) returns (Data) { // option (google.api.http).get = "/v2/{resource=**}"; // } // } // // Example of a mixin configuration: // // apis: // - name: google.storage.v2.Storage // mixins: // - name: google.acl.v1.AccessControl // // The mixin construct implies that all methods in `AccessControl` are // also declared with same name and request/response types in // `Storage`. A documentation generator or annotation processor will // see the effective `Storage.GetAcl` method after inherting // documentation and annotations as follows: // // service Storage { // // Get the underlying ACL object. // rpc GetAcl(GetAclRequest) returns (Acl) { // option (google.api.http).get = "/v2/{resource=**}:getAcl"; // } // ... // } // // Note how the version in the path pattern changed from `v1` to `v2`. // // If the `root` field in the mixin is specified, it should be a // relative path under which inherited HTTP paths are placed. Example: // // apis: // - name: google.storage.v2.Storage // mixins: // - name: google.acl.v1.AccessControl // root: acls // // This implies the following inherited HTTP annotation: // // service Storage { // // Get the underlying ACL object. // rpc GetAcl(GetAclRequest) returns (Acl) { // option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; // } // ... // } message Mixin { // The fully qualified name of the interface which is included. string name = 1; // If non-empty specifies a path under which inherited HTTP paths // are rooted. string root = 2; } kvproto-6.1.0-alpha/include/google/protobuf/compiler/000077500000000000000000000000001421456440000226565ustar00rootroot00000000000000kvproto-6.1.0-alpha/include/google/protobuf/compiler/plugin.proto000066400000000000000000000177301421456440000252510ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Author: kenton@google.com (Kenton Varda) // // WARNING: The plugin interface is currently EXPERIMENTAL and is subject to // change. // // protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is // just a program that reads a CodeGeneratorRequest from stdin and writes a // CodeGeneratorResponse to stdout. // // Plugins written using C++ can use google/protobuf/compiler/plugin.h instead // of dealing with the raw protocol defined here. // // A plugin executable needs only to be placed somewhere in the path. The // plugin should be named "protoc-gen-$NAME", and will then be used when the // flag "--${NAME}_out" is passed to protoc. syntax = "proto2"; package google.protobuf.compiler; option java_package = "com.google.protobuf.compiler"; option java_outer_classname = "PluginProtos"; option go_package = "plugin_go"; import "google/protobuf/descriptor.proto"; // The version number of protocol compiler. message Version { optional int32 major = 1; optional int32 minor = 2; optional int32 patch = 3; // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should // be empty for mainline stable releases. optional string suffix = 4; } // An encoded CodeGeneratorRequest is written to the plugin's stdin. message CodeGeneratorRequest { // The .proto files that were explicitly listed on the command-line. The // code generator should generate code only for these files. Each file's // descriptor will be included in proto_file, below. repeated string file_to_generate = 1; // The generator parameter passed on the command-line. optional string parameter = 2; // FileDescriptorProtos for all files in files_to_generate and everything // they import. The files will appear in topological order, so each file // appears before any file that imports it. // // protoc guarantees that all proto_files will be written after // the fields above, even though this is not technically guaranteed by the // protobuf wire format. This theoretically could allow a plugin to stream // in the FileDescriptorProtos and handle them one by one rather than read // the entire set into memory at once. However, as of this writing, this // is not similarly optimized on protoc's end -- it will store all fields in // memory at once before sending them to the plugin. // // Type names of fields and extensions in the FileDescriptorProto are always // fully qualified. repeated FileDescriptorProto proto_file = 15; // The version number of protocol compiler. optional Version compiler_version = 3; } // The plugin writes an encoded CodeGeneratorResponse to stdout. message CodeGeneratorResponse { // Error message. If non-empty, code generation failed. The plugin process // should exit with status code zero even if it reports an error in this way. // // This should be used to indicate errors in .proto files which prevent the // code generator from generating correct code. Errors which indicate a // problem in protoc itself -- such as the input CodeGeneratorRequest being // unparseable -- should be reported by writing a message to stderr and // exiting with a non-zero status code. optional string error = 1; // Represents a single generated file. message File { // The file name, relative to the output directory. The name must not // contain "." or ".." components and must be relative, not be absolute (so, // the file cannot lie outside the output directory). "/" must be used as // the path separator, not "\". // // If the name is omitted, the content will be appended to the previous // file. This allows the generator to break large files into small chunks, // and allows the generated text to be streamed back to protoc so that large // files need not reside completely in memory at one time. Note that as of // this writing protoc does not optimize for this -- it will read the entire // CodeGeneratorResponse before writing files to disk. optional string name = 1; // If non-empty, indicates that the named file should already exist, and the // content here is to be inserted into that file at a defined insertion // point. This feature allows a code generator to extend the output // produced by another code generator. The original generator may provide // insertion points by placing special annotations in the file that look // like: // @@protoc_insertion_point(NAME) // The annotation can have arbitrary text before and after it on the line, // which allows it to be placed in a comment. NAME should be replaced with // an identifier naming the point -- this is what other generators will use // as the insertion_point. Code inserted at this point will be placed // immediately above the line containing the insertion point (thus multiple // insertions to the same point will come out in the order they were added). // The double-@ is intended to make it unlikely that the generated code // could contain things that look like insertion points by accident. // // For example, the C++ code generator places the following line in the // .pb.h files that it generates: // // @@protoc_insertion_point(namespace_scope) // This line appears within the scope of the file's package namespace, but // outside of any particular class. Another plugin can then specify the // insertion_point "namespace_scope" to generate additional classes or // other declarations that should be placed in this scope. // // Note that if the line containing the insertion point begins with // whitespace, the same whitespace will be added to every line of the // inserted text. This is useful for languages like Python, where // indentation matters. In these languages, the insertion point comment // should be indented the same amount as any inserted code will need to be // in order to work correctly in that context. // // The code generator that generates the initial file and the one which // inserts into it must both run as part of a single invocation of protoc. // Code generators are executed in the order in which they appear on the // command line. // // If |insertion_point| is present, |name| must also be present. optional string insertion_point = 2; // The file contents. optional string content = 15; } repeated File file = 15; } kvproto-6.1.0-alpha/include/google/protobuf/descriptor.proto000066400000000000000000001066131421456440000243160ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. // // The messages in this file describe the definitions found in .proto files. // A valid .proto file can be translated directly to a FileDescriptorProto // without any other information (e.g. without reading its imports). syntax = "proto2"; package google.protobuf; option go_package = "descriptor"; option java_package = "com.google.protobuf"; option java_outer_classname = "DescriptorProtos"; option csharp_namespace = "Google.Protobuf.Reflection"; option objc_class_prefix = "GPB"; option cc_enable_arenas = true; // descriptor.proto must be optimized for speed because reflection-based // algorithms don't work during bootstrapping. option optimize_for = SPEED; // The protocol compiler can output a FileDescriptorSet containing the .proto // files it parses. message FileDescriptorSet { repeated FileDescriptorProto file = 1; } // Describes a complete .proto file. message FileDescriptorProto { optional string name = 1; // file name, relative to root of source tree optional string package = 2; // e.g. "foo", "foo.bar", etc. // Names of files imported by this file. repeated string dependency = 3; // Indexes of the public imported files in the dependency list above. repeated int32 public_dependency = 10; // Indexes of the weak imported files in the dependency list. // For Google-internal migration only. Do not use. repeated int32 weak_dependency = 11; // All top-level definitions in this file. repeated DescriptorProto message_type = 4; repeated EnumDescriptorProto enum_type = 5; repeated ServiceDescriptorProto service = 6; repeated FieldDescriptorProto extension = 7; optional FileOptions options = 8; // This field contains optional information about the original source code. // You may safely remove this entire field without harming runtime // functionality of the descriptors -- the information is needed only by // development tools. optional SourceCodeInfo source_code_info = 9; // The syntax of the proto file. // The supported values are "proto2" and "proto3". optional string syntax = 12; } // Describes a message type. message DescriptorProto { optional string name = 1; repeated FieldDescriptorProto field = 2; repeated FieldDescriptorProto extension = 6; repeated DescriptorProto nested_type = 3; repeated EnumDescriptorProto enum_type = 4; message ExtensionRange { optional int32 start = 1; optional int32 end = 2; optional ExtensionRangeOptions options = 3; } repeated ExtensionRange extension_range = 5; repeated OneofDescriptorProto oneof_decl = 8; optional MessageOptions options = 7; // Range of reserved tag numbers. Reserved tag numbers may not be used by // fields or extension ranges in the same message. Reserved ranges may // not overlap. message ReservedRange { optional int32 start = 1; // Inclusive. optional int32 end = 2; // Exclusive. } repeated ReservedRange reserved_range = 9; // Reserved field names, which may not be used by fields in the same message. // A given name may only be reserved once. repeated string reserved_name = 10; } message ExtensionRangeOptions { // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } // Describes a field within a message. message FieldDescriptorProto { enum Type { // 0 is reserved for errors. // Order is weird for historical reasons. TYPE_DOUBLE = 1; TYPE_FLOAT = 2; // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if // negative values are likely. TYPE_INT64 = 3; TYPE_UINT64 = 4; // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if // negative values are likely. TYPE_INT32 = 5; TYPE_FIXED64 = 6; TYPE_FIXED32 = 7; TYPE_BOOL = 8; TYPE_STRING = 9; // Tag-delimited aggregate. // Group type is deprecated and not supported in proto3. However, Proto3 // implementations should still be able to parse the group wire format and // treat group fields as unknown fields. TYPE_GROUP = 10; TYPE_MESSAGE = 11; // Length-delimited aggregate. // New in version 2. TYPE_BYTES = 12; TYPE_UINT32 = 13; TYPE_ENUM = 14; TYPE_SFIXED32 = 15; TYPE_SFIXED64 = 16; TYPE_SINT32 = 17; // Uses ZigZag encoding. TYPE_SINT64 = 18; // Uses ZigZag encoding. }; enum Label { // 0 is reserved for errors LABEL_OPTIONAL = 1; LABEL_REQUIRED = 2; LABEL_REPEATED = 3; }; optional string name = 1; optional int32 number = 3; optional Label label = 4; // If type_name is set, this need not be set. If both this and type_name // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. optional Type type = 5; // For message and enum types, this is the name of the type. If the name // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping // rules are used to find the type (i.e. first the nested types within this // message are searched, then within the parent, on up to the root // namespace). optional string type_name = 6; // For extensions, this is the name of the type being extended. It is // resolved in the same manner as type_name. optional string extendee = 2; // For numeric types, contains the original text representation of the value. // For booleans, "true" or "false". // For strings, contains the default text contents (not escaped in any way). // For bytes, contains the C escaped value. All bytes >= 128 are escaped. // TODO(kenton): Base-64 encode? optional string default_value = 7; // If set, gives the index of a oneof in the containing type's oneof_decl // list. This field is a member of that oneof. optional int32 oneof_index = 9; // JSON name of this field. The value is set by protocol compiler. If the // user has set a "json_name" option on this field, that option's value // will be used. Otherwise, it's deduced from the field's name by converting // it to camelCase. optional string json_name = 10; optional FieldOptions options = 8; } // Describes a oneof. message OneofDescriptorProto { optional string name = 1; optional OneofOptions options = 2; } // Describes an enum type. message EnumDescriptorProto { optional string name = 1; repeated EnumValueDescriptorProto value = 2; optional EnumOptions options = 3; // Range of reserved numeric values. Reserved values may not be used by // entries in the same enum. Reserved ranges may not overlap. // // Note that this is distinct from DescriptorProto.ReservedRange in that it // is inclusive such that it can appropriately represent the entire int32 // domain. message EnumReservedRange { optional int32 start = 1; // Inclusive. optional int32 end = 2; // Inclusive. } // Range of reserved numeric values. Reserved numeric values may not be used // by enum values in the same enum declaration. Reserved ranges may not // overlap. repeated EnumReservedRange reserved_range = 4; // Reserved enum value names, which may not be reused. A given name may only // be reserved once. repeated string reserved_name = 5; } // Describes a value within an enum. message EnumValueDescriptorProto { optional string name = 1; optional int32 number = 2; optional EnumValueOptions options = 3; } // Describes a service. message ServiceDescriptorProto { optional string name = 1; repeated MethodDescriptorProto method = 2; optional ServiceOptions options = 3; } // Describes a method of a service. message MethodDescriptorProto { optional string name = 1; // Input and output type names. These are resolved in the same way as // FieldDescriptorProto.type_name, but must refer to a message type. optional string input_type = 2; optional string output_type = 3; optional MethodOptions options = 4; // Identifies if client streams multiple client messages optional bool client_streaming = 5 [default=false]; // Identifies if server streams multiple server messages optional bool server_streaming = 6 [default=false]; } // =================================================================== // Options // Each of the definitions above may have "options" attached. These are // just annotations which may cause code to be generated slightly differently // or may contain hints for code that manipulates protocol messages. // // Clients may define custom options as extensions of the *Options messages. // These extensions may not yet be known at parsing time, so the parser cannot // store the values in them. Instead it stores them in a field in the *Options // message called uninterpreted_option. This field must have the same name // across all *Options messages. We then use this field to populate the // extensions when we build a descriptor, at which point all protos have been // parsed and so all extensions are known. // // Extension numbers for custom options may be chosen as follows: // * For options which will only be used within a single application or // organization, or for experimental options, use field numbers 50000 // through 99999. It is up to you to ensure that you do not use the // same number for multiple options. // * For options which will be published and used publicly by multiple // independent entities, e-mail protobuf-global-extension-registry@google.com // to reserve extension numbers. Simply provide your project name (e.g. // Objective-C plugin) and your project website (if available) -- there's no // need to explain how you intend to use them. Usually you only need one // extension number. You can declare multiple options with only one extension // number by putting them in a sub-message. See the Custom Options section of // the docs for examples: // https://developers.google.com/protocol-buffers/docs/proto#options // If this turns out to be popular, a web service will be set up // to automatically assign option numbers. message FileOptions { // Sets the Java package where classes generated from this .proto will be // placed. By default, the proto package is used, but this is often // inappropriate because proto packages do not normally start with backwards // domain names. optional string java_package = 1; // If set, all the classes from the .proto file are wrapped in a single // outer class with the given name. This applies to both Proto1 // (equivalent to the old "--one_java_file" option) and Proto2 (where // a .proto always translates to a single class, but you may want to // explicitly choose the class name). optional string java_outer_classname = 8; // If set true, then the Java code generator will generate a separate .java // file for each top-level message, enum, and service defined in the .proto // file. Thus, these types will *not* be nested inside the outer class // named by java_outer_classname. However, the outer class will still be // generated to contain the file's getDescriptor() method as well as any // top-level extensions defined in the file. optional bool java_multiple_files = 10 [default=false]; // This option does nothing. optional bool java_generate_equals_and_hash = 20 [deprecated=true]; // If set true, then the Java2 code generator will generate code that // throws an exception whenever an attempt is made to assign a non-UTF-8 // byte sequence to a string field. // Message reflection will do the same. // However, an extension field still accepts non-UTF-8 byte sequences. // This option has no effect on when used with the lite runtime. optional bool java_string_check_utf8 = 27 [default=false]; // Generated classes can be optimized for speed or code size. enum OptimizeMode { SPEED = 1; // Generate complete code for parsing, serialization, // etc. CODE_SIZE = 2; // Use ReflectionOps to implement these methods. LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. } optional OptimizeMode optimize_for = 9 [default=SPEED]; // Sets the Go package where structs generated from this .proto will be // placed. If omitted, the Go package will be derived from the following: // - The basename of the package import path, if provided. // - Otherwise, the package statement in the .proto file, if present. // - Otherwise, the basename of the .proto file, without extension. optional string go_package = 11; // Should generic services be generated in each language? "Generic" services // are not specific to any particular RPC system. They are generated by the // main code generators in each language (without additional plugins). // Generic services were the only kind of service generation supported by // early versions of google.protobuf. // // Generic services are now considered deprecated in favor of using plugins // that generate code specific to your particular RPC system. Therefore, // these default to false. Old code which depends on generic services should // explicitly set them to true. optional bool cc_generic_services = 16 [default=false]; optional bool java_generic_services = 17 [default=false]; optional bool py_generic_services = 18 [default=false]; optional bool php_generic_services = 42 [default=false]; // Is this file deprecated? // Depending on the target platform, this can emit Deprecated annotations // for everything in the file, or it will be completely ignored; in the very // least, this is a formalization for deprecating files. optional bool deprecated = 23 [default=false]; // Enables the use of arenas for the proto messages in this file. This applies // only to generated classes for C++. optional bool cc_enable_arenas = 31 [default=false]; // Sets the objective c class prefix which is prepended to all objective c // generated classes from this .proto. There is no default. optional string objc_class_prefix = 36; // Namespace for generated classes; defaults to the package. optional string csharp_namespace = 37; // By default Swift generators will take the proto package and CamelCase it // replacing '.' with underscore and use that to prefix the types/symbols // defined. When this options is provided, they will use this value instead // to prefix the types/symbols defined. optional string swift_prefix = 39; // Sets the php class prefix which is prepended to all php generated classes // from this .proto. Default is empty. optional string php_class_prefix = 40; // Use this option to change the namespace of php generated classes. Default // is empty. When this option is empty, the package name will be used for // determining the namespace. optional string php_namespace = 41; // The parser stores options it doesn't recognize here. // See the documentation for the "Options" section above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. // See the documentation for the "Options" section above. extensions 1000 to max; //reserved 38; } message MessageOptions { // Set true to use the old proto1 MessageSet wire format for extensions. // This is provided for backwards-compatibility with the MessageSet wire // format. You should not use this for any other reason: It's less // efficient, has fewer features, and is more complicated. // // The message must be defined exactly as follows: // message Foo { // option message_set_wire_format = true; // extensions 4 to max; // } // Note that the message cannot have any defined fields; MessageSets only // have extensions. // // All extensions of your type must be singular messages; e.g. they cannot // be int32s, enums, or repeated messages. // // Because this is an option, the above two restrictions are not enforced by // the protocol compiler. optional bool message_set_wire_format = 1 [default=false]; // Disables the generation of the standard "descriptor()" accessor, which can // conflict with a field of the same name. This is meant to make migration // from proto1 easier; new code should avoid fields named "descriptor". optional bool no_standard_descriptor_accessor = 2 [default=false]; // Is this message deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the message, or it will be completely ignored; in the very least, // this is a formalization for deprecating messages. optional bool deprecated = 3 [default=false]; // Whether the message is an automatically generated map entry type for the // maps field. // // For maps fields: // map map_field = 1; // The parsed descriptor looks like: // message MapFieldEntry { // option map_entry = true; // optional KeyType key = 1; // optional ValueType value = 2; // } // repeated MapFieldEntry map_field = 1; // // Implementations may choose not to generate the map_entry=true message, but // use a native map in the target language to hold the keys and values. // The reflection APIs in such implementions still need to work as // if the field is a repeated message field. // // NOTE: Do not set the option in .proto files. Always use the maps syntax // instead. The option should only be implicitly set by the proto compiler // parser. optional bool map_entry = 7; //reserved 8; // javalite_serializable //reserved 9; // javanano_as_lite // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } message FieldOptions { // The ctype option instructs the C++ code generator to use a different // representation of the field than it normally would. See the specific // options below. This option is not yet implemented in the open source // release -- sorry, we'll try to include it in a future version! optional CType ctype = 1 [default = STRING]; enum CType { // Default mode. STRING = 0; CORD = 1; STRING_PIECE = 2; } // The packed option can be enabled for repeated primitive fields to enable // a more efficient representation on the wire. Rather than repeatedly // writing the tag and type for each element, the entire array is encoded as // a single length-delimited blob. In proto3, only explicit setting it to // false will avoid using packed encoding. optional bool packed = 2; // The jstype option determines the JavaScript type used for values of the // field. The option is permitted only for 64 bit integral and fixed types // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING // is represented as JavaScript string, which avoids loss of precision that // can happen when a large value is converted to a floating point JavaScript. // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to // use the JavaScript "number" type. The behavior of the default option // JS_NORMAL is implementation dependent. // // This option is an enum to permit additional types to be added, e.g. // goog.math.Integer. optional JSType jstype = 6 [default = JS_NORMAL]; enum JSType { // Use the default type. JS_NORMAL = 0; // Use JavaScript strings. JS_STRING = 1; // Use JavaScript numbers. JS_NUMBER = 2; } // Should this field be parsed lazily? Lazy applies only to message-type // fields. It means that when the outer message is initially parsed, the // inner message's contents will not be parsed but instead stored in encoded // form. The inner message will actually be parsed when it is first accessed. // // This is only a hint. Implementations are free to choose whether to use // eager or lazy parsing regardless of the value of this option. However, // setting this option true suggests that the protocol author believes that // using lazy parsing on this field is worth the additional bookkeeping // overhead typically needed to implement it. // // This option does not affect the public interface of any generated code; // all method signatures remain the same. Furthermore, thread-safety of the // interface is not affected by this option; const methods remain safe to // call from multiple threads concurrently, while non-const methods continue // to require exclusive access. // // // Note that implementations may choose not to check required fields within // a lazy sub-message. That is, calling IsInitialized() on the outer message // may return true even if the inner message has missing required fields. // This is necessary because otherwise the inner message would have to be // parsed in order to perform the check, defeating the purpose of lazy // parsing. An implementation which chooses not to check required fields // must be consistent about it. That is, for any particular sub-message, the // implementation must either *always* check its required fields, or *never* // check its required fields, regardless of whether or not the message has // been parsed. optional bool lazy = 5 [default=false]; // Is this field deprecated? // Depending on the target platform, this can emit Deprecated annotations // for accessors, or it will be completely ignored; in the very least, this // is a formalization for deprecating fields. optional bool deprecated = 3 [default=false]; // For Google-internal migration only. Do not use. optional bool weak = 10 [default=false]; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; //reserved 4; // removed jtype } message OneofOptions { // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } message EnumOptions { // Set this option to true to allow mapping different tag names to the same // value. optional bool allow_alias = 2; // Is this enum deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the enum, or it will be completely ignored; in the very least, this // is a formalization for deprecating enums. optional bool deprecated = 3 [default=false]; //reserved 5; // javanano_as_lite // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } message EnumValueOptions { // Is this enum value deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the enum value, or it will be completely ignored; in the very least, // this is a formalization for deprecating enum values. optional bool deprecated = 1 [default=false]; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } message ServiceOptions { // Note: Field numbers 1 through 32 are reserved for Google's internal RPC // framework. We apologize for hoarding these numbers to ourselves, but // we were already using them long before we decided to release Protocol // Buffers. // Is this service deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the service, or it will be completely ignored; in the very least, // this is a formalization for deprecating services. optional bool deprecated = 33 [default=false]; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } message MethodOptions { // Note: Field numbers 1 through 32 are reserved for Google's internal RPC // framework. We apologize for hoarding these numbers to ourselves, but // we were already using them long before we decided to release Protocol // Buffers. // Is this method deprecated? // Depending on the target platform, this can emit Deprecated annotations // for the method, or it will be completely ignored; in the very least, // this is a formalization for deprecating methods. optional bool deprecated = 33 [default=false]; // Is this method side-effect-free (or safe in HTTP parlance), or idempotent, // or neither? HTTP based RPC implementation may choose GET verb for safe // methods, and PUT verb for idempotent methods instead of the default POST. enum IdempotencyLevel { IDEMPOTENCY_UNKNOWN = 0; NO_SIDE_EFFECTS = 1; // implies idempotent IDEMPOTENT = 2; // idempotent, but may have side effects } optional IdempotencyLevel idempotency_level = 34 [default=IDEMPOTENCY_UNKNOWN]; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; } // A message representing a option the parser does not recognize. This only // appears in options protos created by the compiler::Parser class. // DescriptorPool resolves these when building Descriptor objects. Therefore, // options protos in descriptor objects (e.g. returned by Descriptor::options(), // or produced by Descriptor::CopyTo()) will never have UninterpretedOptions // in them. message UninterpretedOption { // The name of the uninterpreted option. Each string represents a segment in // a dot-separated name. is_extension is true iff a segment represents an // extension (denoted with parentheses in options specs in .proto files). // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents // "foo.(bar.baz).qux". message NamePart { required string name_part = 1; required bool is_extension = 2; } repeated NamePart name = 2; // The value of the uninterpreted option, in whatever type the tokenizer // identified it as during parsing. Exactly one of these should be set. optional string identifier_value = 3; optional uint64 positive_int_value = 4; optional int64 negative_int_value = 5; optional double double_value = 6; optional bytes string_value = 7; optional string aggregate_value = 8; } // =================================================================== // Optional source code info // Encapsulates information about the original source file from which a // FileDescriptorProto was generated. message SourceCodeInfo { // A Location identifies a piece of source code in a .proto file which // corresponds to a particular definition. This information is intended // to be useful to IDEs, code indexers, documentation generators, and similar // tools. // // For example, say we have a file like: // message Foo { // optional string foo = 1; // } // Let's look at just the field definition: // optional string foo = 1; // ^ ^^ ^^ ^ ^^^ // a bc de f ghi // We have the following locations: // span path represents // [a,i) [ 4, 0, 2, 0 ] The whole field definition. // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). // // Notes: // - A location may refer to a repeated field itself (i.e. not to any // particular index within it). This is used whenever a set of elements are // logically enclosed in a single code segment. For example, an entire // extend block (possibly containing multiple extension definitions) will // have an outer location whose path refers to the "extensions" repeated // field without an index. // - Multiple locations may have the same path. This happens when a single // logical declaration is spread out across multiple places. The most // obvious example is the "extend" block again -- there may be multiple // extend blocks in the same scope, each of which will have the same path. // - A location's span is not always a subset of its parent's span. For // example, the "extendee" of an extension declaration appears at the // beginning of the "extend" block and is shared by all extensions within // the block. // - Just because a location's span is a subset of some other location's span // does not mean that it is a descendent. For example, a "group" defines // both a type and a field in a single declaration. Thus, the locations // corresponding to the type and field and their components will overlap. // - Code which tries to interpret locations should probably be designed to // ignore those that it doesn't understand, as more types of locations could // be recorded in the future. repeated Location location = 1; message Location { // Identifies which part of the FileDescriptorProto was defined at this // location. // // Each element is a field number or an index. They form a path from // the root FileDescriptorProto to the place where the definition. For // example, this path: // [ 4, 3, 2, 7, 1 ] // refers to: // file.message_type(3) // 4, 3 // .field(7) // 2, 7 // .name() // 1 // This is because FileDescriptorProto.message_type has field number 4: // repeated DescriptorProto message_type = 4; // and DescriptorProto.field has field number 2: // repeated FieldDescriptorProto field = 2; // and FieldDescriptorProto.name has field number 1: // optional string name = 1; // // Thus, the above path gives the location of a field name. If we removed // the last element: // [ 4, 3, 2, 7 ] // this path refers to the whole field declaration (from the beginning // of the label to the terminating semicolon). repeated int32 path = 1 [packed=true]; // Always has exactly three or four elements: start line, start column, // end line (optional, otherwise assumed same as start line), end column. // These are packed into a single field for efficiency. Note that line // and column numbers are zero-based -- typically you will want to add // 1 to each before displaying to a user. repeated int32 span = 2 [packed=true]; // If this SourceCodeInfo represents a complete declaration, these are any // comments appearing before and after the declaration which appear to be // attached to the declaration. // // A series of line comments appearing on consecutive lines, with no other // tokens appearing on those lines, will be treated as a single comment. // // leading_detached_comments will keep paragraphs of comments that appear // before (but not connected to) the current element. Each paragraph, // separated by empty lines, will be one comment element in the repeated // field. // // Only the comment content is provided; comment markers (e.g. //) are // stripped out. For block comments, leading whitespace and an asterisk // will be stripped from the beginning of each line other than the first. // Newlines are included in the output. // // Examples: // // optional int32 foo = 1; // Comment attached to foo. // // Comment attached to bar. // optional int32 bar = 2; // // optional string baz = 3; // // Comment attached to baz. // // Another line attached to baz. // // // Comment attached to qux. // // // // Another line attached to qux. // optional double qux = 4; // // // Detached comment for corge. This is not leading or trailing comments // // to qux or corge because there are blank lines separating it from // // both. // // // Detached comment for corge paragraph 2. // // optional string corge = 5; // /* Block comment attached // * to corge. Leading asterisks // * will be removed. */ // /* Block comment attached to // * grault. */ // optional int32 grault = 6; // // // ignored detached comments. optional string leading_comments = 3; optional string trailing_comments = 4; repeated string leading_detached_comments = 6; } } // Describes the relationship between generated code and its original source // file. A GeneratedCodeInfo message is associated with only one generated // source file, but may contain references to different source .proto files. message GeneratedCodeInfo { // An Annotation connects some span of text in generated code to an element // of its generating .proto file. repeated Annotation annotation = 1; message Annotation { // Identifies the element in the original source .proto file. This field // is formatted the same as SourceCodeInfo.Location.path. repeated int32 path = 1 [packed=true]; // Identifies the filesystem path to the original source .proto. optional string source_file = 2; // Identifies the starting offset in bytes in the generated code // that relates to the identified object. optional int32 begin = 3; // Identifies the ending offset in bytes in the generated code that // relates to the identified offset. The end offset should be one past // the last relevant byte (so the length of the text = end - begin). optional int32 end = 4; } } kvproto-6.1.0-alpha/include/google/protobuf/duration.proto000066400000000000000000000113651421456440000237640ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "DurationProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; // A Duration represents a signed, fixed-length span of time represented // as a count of seconds and fractions of seconds at nanosecond // resolution. It is independent of any calendar and concepts like "day" // or "month". It is related to Timestamp in that the difference between // two Timestamp values is a Duration and it can be added or subtracted // from a Timestamp. Range is approximately +-10,000 years. // // # Examples // // Example 1: Compute Duration from two Timestamps in pseudo code. // // Timestamp start = ...; // Timestamp end = ...; // Duration duration = ...; // // duration.seconds = end.seconds - start.seconds; // duration.nanos = end.nanos - start.nanos; // // if (duration.seconds < 0 && duration.nanos > 0) { // duration.seconds += 1; // duration.nanos -= 1000000000; // } else if (durations.seconds > 0 && duration.nanos < 0) { // duration.seconds -= 1; // duration.nanos += 1000000000; // } // // Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. // // Timestamp start = ...; // Duration duration = ...; // Timestamp end = ...; // // end.seconds = start.seconds + duration.seconds; // end.nanos = start.nanos + duration.nanos; // // if (end.nanos < 0) { // end.seconds -= 1; // end.nanos += 1000000000; // } else if (end.nanos >= 1000000000) { // end.seconds += 1; // end.nanos -= 1000000000; // } // // Example 3: Compute Duration from datetime.timedelta in Python. // // td = datetime.timedelta(days=3, minutes=10) // duration = Duration() // duration.FromTimedelta(td) // // # JSON Mapping // // In JSON format, the Duration type is encoded as a string rather than an // object, where the string ends in the suffix "s" (indicating seconds) and // is preceded by the number of seconds, with nanoseconds expressed as // fractional seconds. For example, 3 seconds with 0 nanoseconds should be // encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should // be expressed in JSON format as "3.000000001s", and 3 seconds and 1 // microsecond should be expressed in JSON format as "3.000001s". // // message Duration { // Signed seconds of the span of time. Must be from -315,576,000,000 // to +315,576,000,000 inclusive. Note: these bounds are computed from: // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years int64 seconds = 1; // Signed fractions of a second at nanosecond resolution of the span // of time. Durations less than one second are represented with a 0 // `seconds` field and a positive or negative `nanos` field. For durations // of one second or more, a non-zero value for the `nanos` field must be // of the same sign as the `seconds` field. Must be from -999,999,999 // to +999,999,999 inclusive. int32 nanos = 2; } kvproto-6.1.0-alpha/include/google/protobuf/empty.proto000066400000000000000000000045241421456440000232740ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "EmptyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; option cc_enable_arenas = true; // A generic empty message that you can re-use to avoid defining duplicated // empty messages in your APIs. A typical example is to use it as the request // or the response type of an API method. For instance: // // service Foo { // rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); // } // // The JSON representation for `Empty` is empty JSON object `{}`. message Empty {} kvproto-6.1.0-alpha/include/google/protobuf/field_mask.proto000066400000000000000000000177201421456440000242360ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "FieldMaskProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; option go_package = "types"; // `FieldMask` represents a set of symbolic field paths, for example: // // paths: "f.a" // paths: "f.b.d" // // Here `f` represents a field in some root message, `a` and `b` // fields in the message found in `f`, and `d` a field found in the // message in `f.b`. // // Field masks are used to specify a subset of fields that should be // returned by a get operation or modified by an update operation. // Field masks also have a custom JSON encoding (see below). // // # Field Masks in Projections // // When used in the context of a projection, a response message or // sub-message is filtered by the API to only contain those fields as // specified in the mask. For example, if the mask in the previous // example is applied to a response message as follows: // // f { // a : 22 // b { // d : 1 // x : 2 // } // y : 13 // } // z: 8 // // The result will not contain specific values for fields x,y and z // (their value will be set to the default, and omitted in proto text // output): // // // f { // a : 22 // b { // d : 1 // } // } // // A repeated field is not allowed except at the last position of a // paths string. // // If a FieldMask object is not present in a get operation, the // operation applies to all fields (as if a FieldMask of all fields // had been specified). // // Note that a field mask does not necessarily apply to the // top-level response message. In case of a REST get operation, the // field mask applies directly to the response, but in case of a REST // list operation, the mask instead applies to each individual message // in the returned resource list. In case of a REST custom method, // other definitions may be used. Where the mask applies will be // clearly documented together with its declaration in the API. In // any case, the effect on the returned resource/resources is required // behavior for APIs. // // # Field Masks in Update Operations // // A field mask in update operations specifies which fields of the // targeted resource are going to be updated. The API is required // to only change the values of the fields as specified in the mask // and leave the others untouched. If a resource is passed in to // describe the updated values, the API ignores the values of all // fields not covered by the mask. // // If a repeated field is specified for an update operation, the existing // repeated values in the target resource will be overwritten by the new values. // Note that a repeated field is only allowed in the last position of a `paths` // string. // // If a sub-message is specified in the last position of the field mask for an // update operation, then the existing sub-message in the target resource is // overwritten. Given the target message: // // f { // b { // d : 1 // x : 2 // } // c : 1 // } // // And an update message: // // f { // b { // d : 10 // } // } // // then if the field mask is: // // paths: "f.b" // // then the result will be: // // f { // b { // d : 10 // } // c : 1 // } // // However, if the update mask was: // // paths: "f.b.d" // // then the result would be: // // f { // b { // d : 10 // x : 2 // } // c : 1 // } // // In order to reset a field's value to the default, the field must // be in the mask and set to the default value in the provided resource. // Hence, in order to reset all fields of a resource, provide a default // instance of the resource and set all fields in the mask, or do // not provide a mask as described below. // // If a field mask is not present on update, the operation applies to // all fields (as if a field mask of all fields has been specified). // Note that in the presence of schema evolution, this may mean that // fields the client does not know and has therefore not filled into // the request will be reset to their default. If this is unwanted // behavior, a specific service may require a client to always specify // a field mask, producing an error if not. // // As with get operations, the location of the resource which // describes the updated values in the request message depends on the // operation kind. In any case, the effect of the field mask is // required to be honored by the API. // // ## Considerations for HTTP REST // // The HTTP kind of an update operation which uses a field mask must // be set to PATCH instead of PUT in order to satisfy HTTP semantics // (PUT must only be used for full updates). // // # JSON Encoding of Field Masks // // In JSON, a field mask is encoded as a single string where paths are // separated by a comma. Fields name in each path are converted // to/from lower-camel naming conventions. // // As an example, consider the following message declarations: // // message Profile { // User user = 1; // Photo photo = 2; // } // message User { // string display_name = 1; // string address = 2; // } // // In proto a field mask for `Profile` may look as such: // // mask { // paths: "user.display_name" // paths: "photo" // } // // In JSON, the same mask is represented as below: // // { // mask: "user.displayName,photo" // } // // # Field Masks and Oneof Fields // // Field masks treat fields in oneofs just as regular fields. Consider the // following message: // // message SampleMessage { // oneof test_oneof { // string name = 4; // SubMessage sub_message = 9; // } // } // // The field mask can be: // // mask { // paths: "name" // } // // Or: // // mask { // paths: "sub_message" // } // // Note that oneof type names ("test_oneof" in this case) cannot be used in // paths. // // ## Field Mask Verification // // The implementation of the all the API methods, which have any FieldMask type // field in the request, should verify the included field paths, and return // `INVALID_ARGUMENT` error if any path is duplicated or unmappable. message FieldMask { // The set of field mask paths. repeated string paths = 1; } kvproto-6.1.0-alpha/include/google/protobuf/source_context.proto000066400000000000000000000043641421456440000252040ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "SourceContextProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; option go_package = "types"; // `SourceContext` represents information about the source of a // protobuf element, like the file in which it is defined. message SourceContext { // The path-qualified name of the .proto file that contained the associated // protobuf element. For example: `"google/protobuf/source_context.proto"`. string file_name = 1; } kvproto-6.1.0-alpha/include/google/protobuf/struct.proto000066400000000000000000000072311421456440000234600ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "StructProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; // `Struct` represents a structured data value, consisting of fields // which map to dynamically typed values. In some languages, `Struct` // might be supported by a native representation. For example, in // scripting languages like JS a struct is represented as an // object. The details of that representation are described together // with the proto support for the language. // // The JSON representation for `Struct` is JSON object. message Struct { // Unordered map of dynamically typed values. map fields = 1; } // `Value` represents a dynamically typed value which can be either // null, a number, a string, a boolean, a recursive struct value, or a // list of values. A producer of value is expected to set one of that // variants, absence of any variant indicates an error. // // The JSON representation for `Value` is JSON value. message Value { // The kind of value. oneof kind { // Represents a null value. NullValue null_value = 1; // Represents a double value. double number_value = 2; // Represents a string value. string string_value = 3; // Represents a boolean value. bool bool_value = 4; // Represents a structured value. Struct struct_value = 5; // Represents a repeated `Value`. ListValue list_value = 6; } } // `NullValue` is a singleton enumeration to represent the null value for the // `Value` type union. // // The JSON representation for `NullValue` is JSON `null`. enum NullValue { // Null value. NULL_VALUE = 0; } // `ListValue` is a wrapper around a repeated field of values. // // The JSON representation for `ListValue` is JSON array. message ListValue { // Repeated field of dynamically typed values. repeated Value values = 1; } kvproto-6.1.0-alpha/include/google/protobuf/timestamp.proto000066400000000000000000000137141421456440000241420ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "TimestampProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; // A Timestamp represents a point in time independent of any time zone // or calendar, represented as seconds and fractions of seconds at // nanosecond resolution in UTC Epoch time. It is encoded using the // Proleptic Gregorian Calendar which extends the Gregorian calendar // backwards to year one. It is encoded assuming all minutes are 60 // seconds long, i.e. leap seconds are "smeared" so that no leap second // table is needed for interpretation. Range is from // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. // By restricting to that range, we ensure that we can convert to // and from RFC 3339 date strings. // See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). // // # Examples // // Example 1: Compute Timestamp from POSIX `time()`. // // Timestamp timestamp; // timestamp.set_seconds(time(NULL)); // timestamp.set_nanos(0); // // Example 2: Compute Timestamp from POSIX `gettimeofday()`. // // struct timeval tv; // gettimeofday(&tv, NULL); // // Timestamp timestamp; // timestamp.set_seconds(tv.tv_sec); // timestamp.set_nanos(tv.tv_usec * 1000); // // Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. // // FILETIME ft; // GetSystemTimeAsFileTime(&ft); // UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // // // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. // Timestamp timestamp; // timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); // timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); // // Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. // // long millis = System.currentTimeMillis(); // // Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) // .setNanos((int) ((millis % 1000) * 1000000)).build(); // // // Example 5: Compute Timestamp from current time in Python. // // timestamp = Timestamp() // timestamp.GetCurrentTime() // // # JSON Mapping // // In JSON format, the Timestamp type is encoded as a string in the // [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the // format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" // where {year} is always expressed using four digits while {month}, {day}, // {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional // seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), // are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone // is required. A proto3 JSON serializer should always use UTC (as indicated by // "Z") when printing the Timestamp type and a proto3 JSON parser should be // able to accept both UTC and other timezones (as indicated by an offset). // // For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past // 01:30 UTC on January 15, 2017. // // In JavaScript, one can convert a Date object to this format using the // standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] // method. In Python, a standard `datetime.datetime` object can be converted // to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) // with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one // can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( // http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime-- // ) to obtain a formatter capable of generating timestamps in this format. // // message Timestamp { // Represents seconds of UTC time since Unix epoch // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to // 9999-12-31T23:59:59Z inclusive. int64 seconds = 1; // Non-negative fractions of a second at nanosecond resolution. Negative // second values with fractions must still have non-negative nanos values // that count forward in time. Must be from 0 to 999,999,999 // inclusive. int32 nanos = 2; } kvproto-6.1.0-alpha/include/google/protobuf/type.proto000066400000000000000000000141411421456440000231130ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto3"; package google.protobuf; import "google/protobuf/any.proto"; import "google/protobuf/source_context.proto"; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option java_package = "com.google.protobuf"; option java_outer_classname = "TypeProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; option go_package = "types"; // A protocol buffer message type. message Type { // The fully qualified message name. string name = 1; // The list of fields. repeated Field fields = 2; // The list of types appearing in `oneof` definitions in this type. repeated string oneofs = 3; // The protocol buffer options. repeated Option options = 4; // The source context. SourceContext source_context = 5; // The source syntax. Syntax syntax = 6; } // A single field of a message type. message Field { // Basic field types. enum Kind { // Field type unknown. TYPE_UNKNOWN = 0; // Field type double. TYPE_DOUBLE = 1; // Field type float. TYPE_FLOAT = 2; // Field type int64. TYPE_INT64 = 3; // Field type uint64. TYPE_UINT64 = 4; // Field type int32. TYPE_INT32 = 5; // Field type fixed64. TYPE_FIXED64 = 6; // Field type fixed32. TYPE_FIXED32 = 7; // Field type bool. TYPE_BOOL = 8; // Field type string. TYPE_STRING = 9; // Field type group. Proto2 syntax only, and deprecated. TYPE_GROUP = 10; // Field type message. TYPE_MESSAGE = 11; // Field type bytes. TYPE_BYTES = 12; // Field type uint32. TYPE_UINT32 = 13; // Field type enum. TYPE_ENUM = 14; // Field type sfixed32. TYPE_SFIXED32 = 15; // Field type sfixed64. TYPE_SFIXED64 = 16; // Field type sint32. TYPE_SINT32 = 17; // Field type sint64. TYPE_SINT64 = 18; }; // Whether a field is optional, required, or repeated. enum Cardinality { // For fields with unknown cardinality. CARDINALITY_UNKNOWN = 0; // For optional fields. CARDINALITY_OPTIONAL = 1; // For required fields. Proto2 syntax only. CARDINALITY_REQUIRED = 2; // For repeated fields. CARDINALITY_REPEATED = 3; }; // The field type. Kind kind = 1; // The field cardinality. Cardinality cardinality = 2; // The field number. int32 number = 3; // The field name. string name = 4; // The field type URL, without the scheme, for message or enumeration // types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. string type_url = 6; // The index of the field type in `Type.oneofs`, for message or enumeration // types. The first type has index 1; zero means the type is not in the list. int32 oneof_index = 7; // Whether to use alternative packed wire representation. bool packed = 8; // The protocol buffer options. repeated Option options = 9; // The field JSON name. string json_name = 10; // The string value of the default value of this field. Proto2 syntax only. string default_value = 11; } // Enum type definition. message Enum { // Enum type name. string name = 1; // Enum value definitions. repeated EnumValue enumvalue = 2; // Protocol buffer options. repeated Option options = 3; // The source context. SourceContext source_context = 4; // The source syntax. Syntax syntax = 5; } // Enum value definition. message EnumValue { // Enum value name. string name = 1; // Enum value number. int32 number = 2; // Protocol buffer options. repeated Option options = 3; } // A protocol buffer option, which can be attached to a message, field, // enumeration, etc. message Option { // The option's name. For protobuf built-in options (options defined in // descriptor.proto), this is the short name. For example, `"map_entry"`. // For custom options, it should be the fully-qualified name. For example, // `"google.api.http"`. string name = 1; // The option's value packed in an Any message. If the value is a primitive, // the corresponding wrapper type defined in google/protobuf/wrappers.proto // should be used. If the value is an enum, it should be stored as an int32 // value using the google.protobuf.Int32Value type. Any value = 2; } // The syntax in which a protocol buffer element is defined. enum Syntax { // Syntax `proto2`. SYNTAX_PROTO2 = 0; // Syntax `proto3`. SYNTAX_PROTO3 = 1; } kvproto-6.1.0-alpha/include/google/protobuf/wrappers.proto000066400000000000000000000071741421456440000240050ustar00rootroot00000000000000// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Wrappers for primitive (non-message) types. These types are useful // for embedding primitives in the `google.protobuf.Any` type and for places // where we need to distinguish between the absence of a primitive // typed field and its default value. syntax = "proto3"; package google.protobuf; option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "types"; option java_package = "com.google.protobuf"; option java_outer_classname = "WrappersProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; // Wrapper message for `double`. // // The JSON representation for `DoubleValue` is JSON number. message DoubleValue { // The double value. double value = 1; } // Wrapper message for `float`. // // The JSON representation for `FloatValue` is JSON number. message FloatValue { // The float value. float value = 1; } // Wrapper message for `int64`. // // The JSON representation for `Int64Value` is JSON string. message Int64Value { // The int64 value. int64 value = 1; } // Wrapper message for `uint64`. // // The JSON representation for `UInt64Value` is JSON string. message UInt64Value { // The uint64 value. uint64 value = 1; } // Wrapper message for `int32`. // // The JSON representation for `Int32Value` is JSON number. message Int32Value { // The int32 value. int32 value = 1; } // Wrapper message for `uint32`. // // The JSON representation for `UInt32Value` is JSON number. message UInt32Value { // The uint32 value. uint32 value = 1; } // Wrapper message for `bool`. // // The JSON representation for `BoolValue` is JSON `true` and `false`. message BoolValue { // The bool value. bool value = 1; } // Wrapper message for `string`. // // The JSON representation for `StringValue` is JSON string. message StringValue { // The string value. string value = 1; } // Wrapper message for `bytes`. // // The JSON representation for `BytesValue` is JSON string. message BytesValue { // The bytes value. bytes value = 1; } kvproto-6.1.0-alpha/include/rustproto.proto000066400000000000000000000036201421456440000210770ustar00rootroot00000000000000syntax = "proto2"; import "google/protobuf/descriptor.proto"; // see https://github.com/gogo/protobuf/blob/master/gogoproto/gogo.proto // for the original idea package rustproto; extend google.protobuf.FileOptions { // When true, oneof field is generated public optional bool expose_oneof_all = 17001; // When true all fields are public, and not accessors generated optional bool expose_fields_all = 17003; // When false, `get_`, `set_`, `mut_` etc. accessors are not generated optional bool generate_accessors_all = 17004; // Use `bytes::Bytes` for `bytes` fields optional bool carllerche_bytes_for_bytes_all = 17011; // Use `bytes::Bytes` for `string` fields optional bool carllerche_bytes_for_string_all = 17012; // When true, will only generate codes that works with lite runtime. optional bool lite_runtime_all = 17035; } extend google.protobuf.MessageOptions { // When true, oneof field is generated public optional bool expose_oneof = 17001; // When true all fields are public, and not accessors generated optional bool expose_fields = 17003; // When false, `get_`, `set_`, `mut_` etc. accessors are not generated optional bool generate_accessors = 17004; // Use `bytes::Bytes` for `bytes` fields optional bool carllerche_bytes_for_bytes = 17011; // Use `bytes::Bytes` for `string` fields optional bool carllerche_bytes_for_string = 17012; } extend google.protobuf.FieldOptions { // When true all fields are public, and not accessors generated optional bool expose_fields_field = 17003; // When false, `get_`, `set_`, `mut_` etc. accessors are not generated optional bool generate_accessors_field = 17004; // Use `bytes::Bytes` for `bytes` fields optional bool carllerche_bytes_for_bytes_field = 17011; // Use `bytes::Bytes` for `string` fields optional bool carllerche_bytes_for_string_field = 17012; }kvproto-6.1.0-alpha/pkg/000077500000000000000000000000001421456440000150665ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/backup/000077500000000000000000000000001421456440000163335ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/backup/backup.pb.go000066400000000000000000006055501421456440000205420ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: backup.proto package backup import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // sst files compression algorithm type CompressionType int32 const ( CompressionType_UNKNOWN CompressionType = 0 CompressionType_LZ4 CompressionType = 1 CompressionType_SNAPPY CompressionType = 2 CompressionType_ZSTD CompressionType = 3 ) var CompressionType_name = map[int32]string{ 0: "UNKNOWN", 1: "LZ4", 2: "SNAPPY", 3: "ZSTD", } var CompressionType_value = map[string]int32{ "UNKNOWN": 0, "LZ4": 1, "SNAPPY": 2, "ZSTD": 3, } func (x CompressionType) String() string { return proto.EnumName(CompressionType_name, int32(x)) } func (CompressionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{0} } // The message save the metadata of a backup. type BackupMeta struct { // ID and version of backuped cluster. ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` ClusterVersion string `protobuf:"bytes,2,opt,name=cluster_version,json=clusterVersion,proto3" json:"cluster_version,omitempty"` // Save the version of BR running backup jobs. BrVersion string `protobuf:"bytes,11,opt,name=br_version,json=brVersion,proto3" json:"br_version,omitempty"` // The backupmeta scheme version. Version int32 `protobuf:"varint,12,opt,name=version,proto3" json:"version,omitempty"` // A set of files that compose a backup. // Note: `files` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Files []*File `protobuf:"bytes,4,rep,name=files" json:"files,omitempty"` // An index to files contains data files. FileIndex *MetaFile `protobuf:"bytes,13,opt,name=file_index,json=fileIndex" json:"file_index,omitempty"` // A pair of timestamp specifies a time range of a backup. // For full backup, the start_version equals to the end_version, // it means point in time. // For incremental backup, the time range is specified as // (start_version, end_version]. StartVersion uint64 `protobuf:"varint,5,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,6,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` // Table metadata describes database and table info. // Note: `schemas` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Schemas []*Schema `protobuf:"bytes,7,rep,name=schemas" json:"schemas,omitempty"` // An index to files contains Schemas. SchemaIndex *MetaFile `protobuf:"bytes,14,opt,name=schema_index,json=schemaIndex" json:"schema_index,omitempty"` // If in raw kv mode, `start_versions`, `end_versions` and `schemas` will be // ignored, and the backup data's range is represented by raw_ranges. IsRawKv bool `protobuf:"varint,8,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. RawRanges []*RawRange `protobuf:"bytes,9,rep,name=raw_ranges,json=rawRanges" json:"raw_ranges,omitempty"` // An index to files contains RawRanges. RawRangeIndex *MetaFile `protobuf:"bytes,15,opt,name=raw_range_index,json=rawRangeIndex" json:"raw_range_index,omitempty"` // In incremental backup, DDLs which are completed in // (lastBackupTS, backupTS] will be stored here. // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Ddls []byte `protobuf:"bytes,10,opt,name=ddls,proto3" json:"ddls,omitempty"` // An index to files contains DDLs. DdlIndexes *MetaFile `protobuf:"bytes,16,opt,name=ddl_indexes,json=ddlIndexes" json:"ddl_indexes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupMeta) Reset() { *m = BackupMeta{} } func (m *BackupMeta) String() string { return proto.CompactTextString(m) } func (*BackupMeta) ProtoMessage() {} func (*BackupMeta) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{0} } func (m *BackupMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupMeta.Merge(dst, src) } func (m *BackupMeta) XXX_Size() int { return m.Size() } func (m *BackupMeta) XXX_DiscardUnknown() { xxx_messageInfo_BackupMeta.DiscardUnknown(m) } var xxx_messageInfo_BackupMeta proto.InternalMessageInfo func (m *BackupMeta) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *BackupMeta) GetClusterVersion() string { if m != nil { return m.ClusterVersion } return "" } func (m *BackupMeta) GetBrVersion() string { if m != nil { return m.BrVersion } return "" } func (m *BackupMeta) GetVersion() int32 { if m != nil { return m.Version } return 0 } func (m *BackupMeta) GetFiles() []*File { if m != nil { return m.Files } return nil } func (m *BackupMeta) GetFileIndex() *MetaFile { if m != nil { return m.FileIndex } return nil } func (m *BackupMeta) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *BackupMeta) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *BackupMeta) GetSchemas() []*Schema { if m != nil { return m.Schemas } return nil } func (m *BackupMeta) GetSchemaIndex() *MetaFile { if m != nil { return m.SchemaIndex } return nil } func (m *BackupMeta) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } func (m *BackupMeta) GetRawRanges() []*RawRange { if m != nil { return m.RawRanges } return nil } func (m *BackupMeta) GetRawRangeIndex() *MetaFile { if m != nil { return m.RawRangeIndex } return nil } func (m *BackupMeta) GetDdls() []byte { if m != nil { return m.Ddls } return nil } func (m *BackupMeta) GetDdlIndexes() *MetaFile { if m != nil { return m.DdlIndexes } return nil } type File struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Sha256 []byte `protobuf:"bytes,2,opt,name=sha256,proto3" json:"sha256,omitempty"` StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` StartVersion uint64 `protobuf:"varint,5,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,6,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` Crc64Xor uint64 `protobuf:"varint,7,opt,name=crc64xor,proto3" json:"crc64xor,omitempty"` TotalKvs uint64 `protobuf:"varint,8,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,9,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` Cf string `protobuf:"bytes,10,opt,name=cf,proto3" json:"cf,omitempty"` Size_ uint64 `protobuf:"varint,11,opt,name=size,proto3" json:"size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *File) Reset() { *m = File{} } func (m *File) String() string { return proto.CompactTextString(m) } func (*File) ProtoMessage() {} func (*File) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{1} } func (m *File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *File) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_File.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *File) XXX_Merge(src proto.Message) { xxx_messageInfo_File.Merge(dst, src) } func (m *File) XXX_Size() int { return m.Size() } func (m *File) XXX_DiscardUnknown() { xxx_messageInfo_File.DiscardUnknown(m) } var xxx_messageInfo_File proto.InternalMessageInfo func (m *File) GetName() string { if m != nil { return m.Name } return "" } func (m *File) GetSha256() []byte { if m != nil { return m.Sha256 } return nil } func (m *File) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *File) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *File) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *File) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *File) GetCrc64Xor() uint64 { if m != nil { return m.Crc64Xor } return 0 } func (m *File) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *File) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func (m *File) GetCf() string { if m != nil { return m.Cf } return "" } func (m *File) GetSize_() uint64 { if m != nil { return m.Size_ } return 0 } // MetaFile describes a multi-level index of data used in backup. type MetaFile struct { // A set of files that contains a MetaFile. // It is used as a multi-level index. MetaFiles []*File `protobuf:"bytes,1,rep,name=meta_files,json=metaFiles" json:"meta_files,omitempty"` // A set of files that contains user data. DataFiles []*File `protobuf:"bytes,2,rep,name=data_files,json=dataFiles" json:"data_files,omitempty"` // A set of files that contains Schemas. Schemas []*Schema `protobuf:"bytes,3,rep,name=schemas" json:"schemas,omitempty"` // A set of files that contains RawRanges. RawRanges []*RawRange `protobuf:"bytes,4,rep,name=raw_ranges,json=rawRanges" json:"raw_ranges,omitempty"` // A set of files that contains DDLs. Ddls [][]byte `protobuf:"bytes,5,rep,name=ddls" json:"ddls,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MetaFile) Reset() { *m = MetaFile{} } func (m *MetaFile) String() string { return proto.CompactTextString(m) } func (*MetaFile) ProtoMessage() {} func (*MetaFile) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{2} } func (m *MetaFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MetaFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MetaFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MetaFile) XXX_Merge(src proto.Message) { xxx_messageInfo_MetaFile.Merge(dst, src) } func (m *MetaFile) XXX_Size() int { return m.Size() } func (m *MetaFile) XXX_DiscardUnknown() { xxx_messageInfo_MetaFile.DiscardUnknown(m) } var xxx_messageInfo_MetaFile proto.InternalMessageInfo func (m *MetaFile) GetMetaFiles() []*File { if m != nil { return m.MetaFiles } return nil } func (m *MetaFile) GetDataFiles() []*File { if m != nil { return m.DataFiles } return nil } func (m *MetaFile) GetSchemas() []*Schema { if m != nil { return m.Schemas } return nil } func (m *MetaFile) GetRawRanges() []*RawRange { if m != nil { return m.RawRanges } return nil } func (m *MetaFile) GetDdls() [][]byte { if m != nil { return m.Ddls } return nil } type Schema struct { Db []byte `protobuf:"bytes,1,opt,name=db,proto3" json:"db,omitempty"` Table []byte `protobuf:"bytes,2,opt,name=table,proto3" json:"table,omitempty"` Crc64Xor uint64 `protobuf:"varint,3,opt,name=crc64xor,proto3" json:"crc64xor,omitempty"` TotalKvs uint64 `protobuf:"varint,4,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` TiflashReplicas uint32 `protobuf:"varint,6,opt,name=tiflash_replicas,json=tiflashReplicas,proto3" json:"tiflash_replicas,omitempty"` // stats represents the dump stats for a analyzed table, which generate by DumpStatsToJSON // https://github.com/pingcap/tidb/blob/e136429d8dc5d70f43cd3f94179b0b9f47595097/statistics/handle/dump.go#L116 Stats []byte `protobuf:"bytes,7,opt,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Schema) Reset() { *m = Schema{} } func (m *Schema) String() string { return proto.CompactTextString(m) } func (*Schema) ProtoMessage() {} func (*Schema) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{3} } func (m *Schema) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Schema.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Schema) XXX_Merge(src proto.Message) { xxx_messageInfo_Schema.Merge(dst, src) } func (m *Schema) XXX_Size() int { return m.Size() } func (m *Schema) XXX_DiscardUnknown() { xxx_messageInfo_Schema.DiscardUnknown(m) } var xxx_messageInfo_Schema proto.InternalMessageInfo func (m *Schema) GetDb() []byte { if m != nil { return m.Db } return nil } func (m *Schema) GetTable() []byte { if m != nil { return m.Table } return nil } func (m *Schema) GetCrc64Xor() uint64 { if m != nil { return m.Crc64Xor } return 0 } func (m *Schema) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *Schema) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func (m *Schema) GetTiflashReplicas() uint32 { if m != nil { return m.TiflashReplicas } return 0 } func (m *Schema) GetStats() []byte { if m != nil { return m.Stats } return nil } type RawRange struct { StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawRange) Reset() { *m = RawRange{} } func (m *RawRange) String() string { return proto.CompactTextString(m) } func (*RawRange) ProtoMessage() {} func (*RawRange) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{4} } func (m *RawRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawRange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawRange) XXX_Merge(src proto.Message) { xxx_messageInfo_RawRange.Merge(dst, src) } func (m *RawRange) XXX_Size() int { return m.Size() } func (m *RawRange) XXX_DiscardUnknown() { xxx_messageInfo_RawRange.DiscardUnknown(m) } var xxx_messageInfo_RawRange proto.InternalMessageInfo func (m *RawRange) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *RawRange) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *RawRange) GetCf() string { if m != nil { return m.Cf } return "" } type ClusterIDError struct { Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"` Request uint64 `protobuf:"varint,2,opt,name=request,proto3" json:"request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ClusterIDError) Reset() { *m = ClusterIDError{} } func (m *ClusterIDError) String() string { return proto.CompactTextString(m) } func (*ClusterIDError) ProtoMessage() {} func (*ClusterIDError) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{5} } func (m *ClusterIDError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ClusterIDError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ClusterIDError.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ClusterIDError) XXX_Merge(src proto.Message) { xxx_messageInfo_ClusterIDError.Merge(dst, src) } func (m *ClusterIDError) XXX_Size() int { return m.Size() } func (m *ClusterIDError) XXX_DiscardUnknown() { xxx_messageInfo_ClusterIDError.DiscardUnknown(m) } var xxx_messageInfo_ClusterIDError proto.InternalMessageInfo func (m *ClusterIDError) GetCurrent() uint64 { if m != nil { return m.Current } return 0 } func (m *ClusterIDError) GetRequest() uint64 { if m != nil { return m.Request } return 0 } type Error struct { Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` // Types that are valid to be assigned to Detail: // *Error_ClusterIdError // *Error_KvError // *Error_RegionError Detail isError_Detail `protobuf_oneof:"detail"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{6} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo type isError_Detail interface { isError_Detail() MarshalTo([]byte) (int, error) Size() int } type Error_ClusterIdError struct { ClusterIdError *ClusterIDError `protobuf:"bytes,3,opt,name=cluster_id_error,json=clusterIdError,oneof"` } type Error_KvError struct { KvError *kvrpcpb.KeyError `protobuf:"bytes,4,opt,name=kv_error,json=kvError,oneof"` } type Error_RegionError struct { RegionError *errorpb.Error `protobuf:"bytes,5,opt,name=region_error,json=regionError,oneof"` } func (*Error_ClusterIdError) isError_Detail() {} func (*Error_KvError) isError_Detail() {} func (*Error_RegionError) isError_Detail() {} func (m *Error) GetDetail() isError_Detail { if m != nil { return m.Detail } return nil } func (m *Error) GetMsg() string { if m != nil { return m.Msg } return "" } func (m *Error) GetClusterIdError() *ClusterIDError { if x, ok := m.GetDetail().(*Error_ClusterIdError); ok { return x.ClusterIdError } return nil } func (m *Error) GetKvError() *kvrpcpb.KeyError { if x, ok := m.GetDetail().(*Error_KvError); ok { return x.KvError } return nil } func (m *Error) GetRegionError() *errorpb.Error { if x, ok := m.GetDetail().(*Error_RegionError); ok { return x.RegionError } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*Error) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _Error_OneofMarshaler, _Error_OneofUnmarshaler, _Error_OneofSizer, []interface{}{ (*Error_ClusterIdError)(nil), (*Error_KvError)(nil), (*Error_RegionError)(nil), } } func _Error_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Error) // detail switch x := m.Detail.(type) { case *Error_ClusterIdError: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ClusterIdError); err != nil { return err } case *Error_KvError: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.KvError); err != nil { return err } case *Error_RegionError: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RegionError); err != nil { return err } case nil: default: return fmt.Errorf("Error.Detail has unexpected type %T", x) } return nil } func _Error_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Error) switch tag { case 3: // detail.cluster_id_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(ClusterIDError) err := b.DecodeMessage(msg) m.Detail = &Error_ClusterIdError{msg} return true, err case 4: // detail.kv_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.KeyError) err := b.DecodeMessage(msg) m.Detail = &Error_KvError{msg} return true, err case 5: // detail.region_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(errorpb.Error) err := b.DecodeMessage(msg) m.Detail = &Error_RegionError{msg} return true, err default: return false, nil } } func _Error_OneofSizer(msg proto.Message) (n int) { m := msg.(*Error) // detail switch x := m.Detail.(type) { case *Error_ClusterIdError: s := proto.Size(x.ClusterIdError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Error_KvError: s := proto.Size(x.KvError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Error_RegionError: s := proto.Size(x.RegionError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type BackupRequest struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,5,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` // The I/O rate limit for backup request. RateLimit uint64 `protobuf:"varint,7,opt,name=rate_limit,json=rateLimit,proto3" json:"rate_limit,omitempty"` // The concurrency for executing the backup request in every tikv node. Concurrency uint32 `protobuf:"varint,8,opt,name=concurrency,proto3" json:"concurrency,omitempty"` StorageBackend *StorageBackend `protobuf:"bytes,9,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` // If raw kv mode is enabled, `start_version` and `end_version` will be ignored, and `cf` // specifies which cf to backup. IsRawKv bool `protobuf:"varint,10,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` Cf string `protobuf:"bytes,11,opt,name=cf,proto3" json:"cf,omitempty"` // algorithm used for compress sst files CompressionType CompressionType `protobuf:"varint,12,opt,name=compression_type,json=compressionType,proto3,enum=backup.CompressionType" json:"compression_type,omitempty"` // sst compression level, some algorithms support negative compression levels CompressionLevel int32 `protobuf:"varint,13,opt,name=compression_level,json=compressionLevel,proto3" json:"compression_level,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupRequest) Reset() { *m = BackupRequest{} } func (m *BackupRequest) String() string { return proto.CompactTextString(m) } func (*BackupRequest) ProtoMessage() {} func (*BackupRequest) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{7} } func (m *BackupRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupRequest.Merge(dst, src) } func (m *BackupRequest) XXX_Size() int { return m.Size() } func (m *BackupRequest) XXX_DiscardUnknown() { xxx_messageInfo_BackupRequest.DiscardUnknown(m) } var xxx_messageInfo_BackupRequest proto.InternalMessageInfo func (m *BackupRequest) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *BackupRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *BackupRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *BackupRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *BackupRequest) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *BackupRequest) GetRateLimit() uint64 { if m != nil { return m.RateLimit } return 0 } func (m *BackupRequest) GetConcurrency() uint32 { if m != nil { return m.Concurrency } return 0 } func (m *BackupRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *BackupRequest) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } func (m *BackupRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *BackupRequest) GetCompressionType() CompressionType { if m != nil { return m.CompressionType } return CompressionType_UNKNOWN } func (m *BackupRequest) GetCompressionLevel() int32 { if m != nil { return m.CompressionLevel } return 0 } type StorageBackend struct { // Types that are valid to be assigned to Backend: // *StorageBackend_Noop // *StorageBackend_Local // *StorageBackend_S3 // *StorageBackend_Gcs // *StorageBackend_CloudDynamic Backend isStorageBackend_Backend `protobuf_oneof:"backend"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StorageBackend) Reset() { *m = StorageBackend{} } func (m *StorageBackend) String() string { return proto.CompactTextString(m) } func (*StorageBackend) ProtoMessage() {} func (*StorageBackend) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{8} } func (m *StorageBackend) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StorageBackend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StorageBackend.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StorageBackend) XXX_Merge(src proto.Message) { xxx_messageInfo_StorageBackend.Merge(dst, src) } func (m *StorageBackend) XXX_Size() int { return m.Size() } func (m *StorageBackend) XXX_DiscardUnknown() { xxx_messageInfo_StorageBackend.DiscardUnknown(m) } var xxx_messageInfo_StorageBackend proto.InternalMessageInfo type isStorageBackend_Backend interface { isStorageBackend_Backend() MarshalTo([]byte) (int, error) Size() int } type StorageBackend_Noop struct { Noop *Noop `protobuf:"bytes,1,opt,name=noop,oneof"` } type StorageBackend_Local struct { Local *Local `protobuf:"bytes,2,opt,name=local,oneof"` } type StorageBackend_S3 struct { S3 *S3 `protobuf:"bytes,3,opt,name=s3,oneof"` } type StorageBackend_Gcs struct { Gcs *GCS `protobuf:"bytes,4,opt,name=gcs,oneof"` } type StorageBackend_CloudDynamic struct { CloudDynamic *CloudDynamic `protobuf:"bytes,5,opt,name=cloud_dynamic,json=cloudDynamic,oneof"` } func (*StorageBackend_Noop) isStorageBackend_Backend() {} func (*StorageBackend_Local) isStorageBackend_Backend() {} func (*StorageBackend_S3) isStorageBackend_Backend() {} func (*StorageBackend_Gcs) isStorageBackend_Backend() {} func (*StorageBackend_CloudDynamic) isStorageBackend_Backend() {} func (m *StorageBackend) GetBackend() isStorageBackend_Backend { if m != nil { return m.Backend } return nil } func (m *StorageBackend) GetNoop() *Noop { if x, ok := m.GetBackend().(*StorageBackend_Noop); ok { return x.Noop } return nil } func (m *StorageBackend) GetLocal() *Local { if x, ok := m.GetBackend().(*StorageBackend_Local); ok { return x.Local } return nil } func (m *StorageBackend) GetS3() *S3 { if x, ok := m.GetBackend().(*StorageBackend_S3); ok { return x.S3 } return nil } func (m *StorageBackend) GetGcs() *GCS { if x, ok := m.GetBackend().(*StorageBackend_Gcs); ok { return x.Gcs } return nil } func (m *StorageBackend) GetCloudDynamic() *CloudDynamic { if x, ok := m.GetBackend().(*StorageBackend_CloudDynamic); ok { return x.CloudDynamic } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*StorageBackend) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _StorageBackend_OneofMarshaler, _StorageBackend_OneofUnmarshaler, _StorageBackend_OneofSizer, []interface{}{ (*StorageBackend_Noop)(nil), (*StorageBackend_Local)(nil), (*StorageBackend_S3)(nil), (*StorageBackend_Gcs)(nil), (*StorageBackend_CloudDynamic)(nil), } } func _StorageBackend_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*StorageBackend) // backend switch x := m.Backend.(type) { case *StorageBackend_Noop: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Noop); err != nil { return err } case *StorageBackend_Local: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Local); err != nil { return err } case *StorageBackend_S3: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.S3); err != nil { return err } case *StorageBackend_Gcs: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Gcs); err != nil { return err } case *StorageBackend_CloudDynamic: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CloudDynamic); err != nil { return err } case nil: default: return fmt.Errorf("StorageBackend.Backend has unexpected type %T", x) } return nil } func _StorageBackend_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*StorageBackend) switch tag { case 1: // backend.noop if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Noop) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Noop{msg} return true, err case 2: // backend.local if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Local) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Local{msg} return true, err case 3: // backend.s3 if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(S3) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_S3{msg} return true, err case 4: // backend.gcs if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(GCS) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Gcs{msg} return true, err case 5: // backend.cloud_dynamic if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(CloudDynamic) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_CloudDynamic{msg} return true, err default: return false, nil } } func _StorageBackend_OneofSizer(msg proto.Message) (n int) { m := msg.(*StorageBackend) // backend switch x := m.Backend.(type) { case *StorageBackend_Noop: s := proto.Size(x.Noop) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_Local: s := proto.Size(x.Local) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_S3: s := proto.Size(x.S3) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_Gcs: s := proto.Size(x.Gcs) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_CloudDynamic: s := proto.Size(x.CloudDynamic) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } // Noop storage backend saves files into void. type Noop struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Noop) Reset() { *m = Noop{} } func (m *Noop) String() string { return proto.CompactTextString(m) } func (*Noop) ProtoMessage() {} func (*Noop) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{9} } func (m *Noop) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Noop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Noop.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Noop) XXX_Merge(src proto.Message) { xxx_messageInfo_Noop.Merge(dst, src) } func (m *Noop) XXX_Size() int { return m.Size() } func (m *Noop) XXX_DiscardUnknown() { xxx_messageInfo_Noop.DiscardUnknown(m) } var xxx_messageInfo_Noop proto.InternalMessageInfo // Local storage backend saves files into local disk type Local struct { Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Local) Reset() { *m = Local{} } func (m *Local) String() string { return proto.CompactTextString(m) } func (*Local) ProtoMessage() {} func (*Local) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{10} } func (m *Local) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Local) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Local.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Local) XXX_Merge(src proto.Message) { xxx_messageInfo_Local.Merge(dst, src) } func (m *Local) XXX_Size() int { return m.Size() } func (m *Local) XXX_DiscardUnknown() { xxx_messageInfo_Local.DiscardUnknown(m) } var xxx_messageInfo_Local proto.InternalMessageInfo func (m *Local) GetPath() string { if m != nil { return m.Path } return "" } // S3 storage backend saves files into S3 compatible storages // For non-aws providers, endpoint must be provided type S3 struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Region string `protobuf:"bytes,2,opt,name=region,proto3" json:"region,omitempty"` Bucket string `protobuf:"bytes,3,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,4,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,5,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` // server side encryption Sse string `protobuf:"bytes,6,opt,name=sse,proto3" json:"sse,omitempty"` Acl string `protobuf:"bytes,7,opt,name=acl,proto3" json:"acl,omitempty"` AccessKey string `protobuf:"bytes,8,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"` SecretAccessKey string `protobuf:"bytes,9,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"` ForcePathStyle bool `protobuf:"varint,10,opt,name=force_path_style,json=forcePathStyle,proto3" json:"force_path_style,omitempty"` SseKmsKeyId string `protobuf:"bytes,11,opt,name=sse_kms_key_id,json=sseKmsKeyId,proto3" json:"sse_kms_key_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *S3) Reset() { *m = S3{} } func (m *S3) String() string { return proto.CompactTextString(m) } func (*S3) ProtoMessage() {} func (*S3) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{11} } func (m *S3) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *S3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_S3.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *S3) XXX_Merge(src proto.Message) { xxx_messageInfo_S3.Merge(dst, src) } func (m *S3) XXX_Size() int { return m.Size() } func (m *S3) XXX_DiscardUnknown() { xxx_messageInfo_S3.DiscardUnknown(m) } var xxx_messageInfo_S3 proto.InternalMessageInfo func (m *S3) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *S3) GetRegion() string { if m != nil { return m.Region } return "" } func (m *S3) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *S3) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *S3) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } func (m *S3) GetSse() string { if m != nil { return m.Sse } return "" } func (m *S3) GetAcl() string { if m != nil { return m.Acl } return "" } func (m *S3) GetAccessKey() string { if m != nil { return m.AccessKey } return "" } func (m *S3) GetSecretAccessKey() string { if m != nil { return m.SecretAccessKey } return "" } func (m *S3) GetForcePathStyle() bool { if m != nil { return m.ForcePathStyle } return false } func (m *S3) GetSseKmsKeyId() string { if m != nil { return m.SseKmsKeyId } return "" } // GCS storage backend saves files into google cloud storage. type GCS struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Bucket string `protobuf:"bytes,2,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,4,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` // If not empty, applies a predefined set of access controls. // See https://cloud.google.com/storage/docs/access-control/lists#predefined-acl // for valid values. PredefinedAcl string `protobuf:"bytes,5,opt,name=predefined_acl,json=predefinedAcl,proto3" json:"predefined_acl,omitempty"` // Service Account Credentials JSON blob // You can get one from https://console.cloud.google.com/apis/credentials, and // copy the content, set it as string here. CredentialsBlob string `protobuf:"bytes,6,opt,name=credentials_blob,json=credentialsBlob,proto3" json:"credentials_blob,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GCS) Reset() { *m = GCS{} } func (m *GCS) String() string { return proto.CompactTextString(m) } func (*GCS) ProtoMessage() {} func (*GCS) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{12} } func (m *GCS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GCS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GCS.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GCS) XXX_Merge(src proto.Message) { xxx_messageInfo_GCS.Merge(dst, src) } func (m *GCS) XXX_Size() int { return m.Size() } func (m *GCS) XXX_DiscardUnknown() { xxx_messageInfo_GCS.DiscardUnknown(m) } var xxx_messageInfo_GCS proto.InternalMessageInfo func (m *GCS) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *GCS) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *GCS) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *GCS) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } func (m *GCS) GetPredefinedAcl() string { if m != nil { return m.PredefinedAcl } return "" } func (m *GCS) GetCredentialsBlob() string { if m != nil { return m.CredentialsBlob } return "" } type Bucket struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Region string `protobuf:"bytes,3,opt,name=region,proto3" json:"region,omitempty"` Bucket string `protobuf:"bytes,4,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,6,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Bucket) Reset() { *m = Bucket{} } func (m *Bucket) String() string { return proto.CompactTextString(m) } func (*Bucket) ProtoMessage() {} func (*Bucket) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{13} } func (m *Bucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Bucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Bucket.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Bucket) XXX_Merge(src proto.Message) { xxx_messageInfo_Bucket.Merge(dst, src) } func (m *Bucket) XXX_Size() int { return m.Size() } func (m *Bucket) XXX_DiscardUnknown() { xxx_messageInfo_Bucket.DiscardUnknown(m) } var xxx_messageInfo_Bucket proto.InternalMessageInfo func (m *Bucket) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *Bucket) GetRegion() string { if m != nil { return m.Region } return "" } func (m *Bucket) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *Bucket) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *Bucket) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } // CloudDynamic allows testing new cloud providers and new fields without changing protobuf definitions type CloudDynamic struct { Bucket *Bucket `protobuf:"bytes,1,opt,name=bucket" json:"bucket,omitempty"` ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` Attrs map[string]string `protobuf:"bytes,3,rep,name=attrs" json:"attrs,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 *CloudDynamic) Reset() { *m = CloudDynamic{} } func (m *CloudDynamic) String() string { return proto.CompactTextString(m) } func (*CloudDynamic) ProtoMessage() {} func (*CloudDynamic) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{14} } func (m *CloudDynamic) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CloudDynamic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CloudDynamic.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CloudDynamic) XXX_Merge(src proto.Message) { xxx_messageInfo_CloudDynamic.Merge(dst, src) } func (m *CloudDynamic) XXX_Size() int { return m.Size() } func (m *CloudDynamic) XXX_DiscardUnknown() { xxx_messageInfo_CloudDynamic.DiscardUnknown(m) } var xxx_messageInfo_CloudDynamic proto.InternalMessageInfo func (m *CloudDynamic) GetBucket() *Bucket { if m != nil { return m.Bucket } return nil } func (m *CloudDynamic) GetProviderName() string { if m != nil { return m.ProviderName } return "" } func (m *CloudDynamic) GetAttrs() map[string]string { if m != nil { return m.Attrs } return nil } type BackupResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` Files []*File `protobuf:"bytes,4,rep,name=files" json:"files,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupResponse) Reset() { *m = BackupResponse{} } func (m *BackupResponse) String() string { return proto.CompactTextString(m) } func (*BackupResponse) ProtoMessage() {} func (*BackupResponse) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{15} } func (m *BackupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupResponse.Merge(dst, src) } func (m *BackupResponse) XXX_Size() int { return m.Size() } func (m *BackupResponse) XXX_DiscardUnknown() { xxx_messageInfo_BackupResponse.DiscardUnknown(m) } var xxx_messageInfo_BackupResponse proto.InternalMessageInfo func (m *BackupResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *BackupResponse) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *BackupResponse) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *BackupResponse) GetFiles() []*File { if m != nil { return m.Files } return nil } type ExternalStorageRestoreRequest struct { StorageBackend *StorageBackend `protobuf:"bytes,1,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` ObjectName string `protobuf:"bytes,2,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` RestoreName string `protobuf:"bytes,3,opt,name=restore_name,json=restoreName,proto3" json:"restore_name,omitempty"` ContentLength uint64 `protobuf:"varint,4,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageRestoreRequest) Reset() { *m = ExternalStorageRestoreRequest{} } func (m *ExternalStorageRestoreRequest) String() string { return proto.CompactTextString(m) } func (*ExternalStorageRestoreRequest) ProtoMessage() {} func (*ExternalStorageRestoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{16} } func (m *ExternalStorageRestoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageRestoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageRestoreRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageRestoreRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageRestoreRequest.Merge(dst, src) } func (m *ExternalStorageRestoreRequest) XXX_Size() int { return m.Size() } func (m *ExternalStorageRestoreRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageRestoreRequest.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageRestoreRequest proto.InternalMessageInfo func (m *ExternalStorageRestoreRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *ExternalStorageRestoreRequest) GetObjectName() string { if m != nil { return m.ObjectName } return "" } func (m *ExternalStorageRestoreRequest) GetRestoreName() string { if m != nil { return m.RestoreName } return "" } func (m *ExternalStorageRestoreRequest) GetContentLength() uint64 { if m != nil { return m.ContentLength } return 0 } type ExternalStorageRestoreResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageRestoreResponse) Reset() { *m = ExternalStorageRestoreResponse{} } func (m *ExternalStorageRestoreResponse) String() string { return proto.CompactTextString(m) } func (*ExternalStorageRestoreResponse) ProtoMessage() {} func (*ExternalStorageRestoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{17} } func (m *ExternalStorageRestoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageRestoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageRestoreResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageRestoreResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageRestoreResponse.Merge(dst, src) } func (m *ExternalStorageRestoreResponse) XXX_Size() int { return m.Size() } func (m *ExternalStorageRestoreResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageRestoreResponse.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageRestoreResponse proto.InternalMessageInfo type ExternalStorageSaveRequest struct { StorageBackend *StorageBackend `protobuf:"bytes,1,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` ObjectName string `protobuf:"bytes,2,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` ContentLength uint64 `protobuf:"varint,3,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageSaveRequest) Reset() { *m = ExternalStorageSaveRequest{} } func (m *ExternalStorageSaveRequest) String() string { return proto.CompactTextString(m) } func (*ExternalStorageSaveRequest) ProtoMessage() {} func (*ExternalStorageSaveRequest) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{18} } func (m *ExternalStorageSaveRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageSaveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageSaveRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageSaveRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageSaveRequest.Merge(dst, src) } func (m *ExternalStorageSaveRequest) XXX_Size() int { return m.Size() } func (m *ExternalStorageSaveRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageSaveRequest.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageSaveRequest proto.InternalMessageInfo func (m *ExternalStorageSaveRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *ExternalStorageSaveRequest) GetObjectName() string { if m != nil { return m.ObjectName } return "" } func (m *ExternalStorageSaveRequest) GetContentLength() uint64 { if m != nil { return m.ContentLength } return 0 } type ExternalStorageSaveResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageSaveResponse) Reset() { *m = ExternalStorageSaveResponse{} } func (m *ExternalStorageSaveResponse) String() string { return proto.CompactTextString(m) } func (*ExternalStorageSaveResponse) ProtoMessage() {} func (*ExternalStorageSaveResponse) Descriptor() ([]byte, []int) { return fileDescriptor_backup_c0317208fdb49464, []int{19} } func (m *ExternalStorageSaveResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageSaveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageSaveResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageSaveResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageSaveResponse.Merge(dst, src) } func (m *ExternalStorageSaveResponse) XXX_Size() int { return m.Size() } func (m *ExternalStorageSaveResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageSaveResponse.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageSaveResponse proto.InternalMessageInfo func init() { proto.RegisterType((*BackupMeta)(nil), "backup.BackupMeta") proto.RegisterType((*File)(nil), "backup.File") proto.RegisterType((*MetaFile)(nil), "backup.MetaFile") proto.RegisterType((*Schema)(nil), "backup.Schema") proto.RegisterType((*RawRange)(nil), "backup.RawRange") proto.RegisterType((*ClusterIDError)(nil), "backup.ClusterIDError") proto.RegisterType((*Error)(nil), "backup.Error") proto.RegisterType((*BackupRequest)(nil), "backup.BackupRequest") proto.RegisterType((*StorageBackend)(nil), "backup.StorageBackend") proto.RegisterType((*Noop)(nil), "backup.Noop") proto.RegisterType((*Local)(nil), "backup.Local") proto.RegisterType((*S3)(nil), "backup.S3") proto.RegisterType((*GCS)(nil), "backup.GCS") proto.RegisterType((*Bucket)(nil), "backup.Bucket") proto.RegisterType((*CloudDynamic)(nil), "backup.CloudDynamic") proto.RegisterMapType((map[string]string)(nil), "backup.CloudDynamic.AttrsEntry") proto.RegisterType((*BackupResponse)(nil), "backup.BackupResponse") proto.RegisterType((*ExternalStorageRestoreRequest)(nil), "backup.ExternalStorageRestoreRequest") proto.RegisterType((*ExternalStorageRestoreResponse)(nil), "backup.ExternalStorageRestoreResponse") proto.RegisterType((*ExternalStorageSaveRequest)(nil), "backup.ExternalStorageSaveRequest") proto.RegisterType((*ExternalStorageSaveResponse)(nil), "backup.ExternalStorageSaveResponse") proto.RegisterEnum("backup.CompressionType", CompressionType_name, CompressionType_value) } // 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 // Client API for Backup service type BackupClient interface { Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) } type backupClient struct { cc *grpc.ClientConn } func NewBackupClient(cc *grpc.ClientConn) BackupClient { return &backupClient{cc} } func (c *backupClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) { stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[0], "/backup.Backup/backup", opts...) if err != nil { return nil, err } x := &backupBackupClient{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 Backup_BackupClient interface { Recv() (*BackupResponse, error) grpc.ClientStream } type backupBackupClient struct { grpc.ClientStream } func (x *backupBackupClient) Recv() (*BackupResponse, error) { m := new(BackupResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for Backup service type BackupServer interface { Backup(*BackupRequest, Backup_BackupServer) error } func RegisterBackupServer(s *grpc.Server, srv BackupServer) { s.RegisterService(&_Backup_serviceDesc, srv) } func _Backup_Backup_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(BackupRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BackupServer).Backup(m, &backupBackupServer{stream}) } type Backup_BackupServer interface { Send(*BackupResponse) error grpc.ServerStream } type backupBackupServer struct { grpc.ServerStream } func (x *backupBackupServer) Send(m *BackupResponse) error { return x.ServerStream.SendMsg(m) } var _Backup_serviceDesc = grpc.ServiceDesc{ ServiceName: "backup.Backup", HandlerType: (*BackupServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "backup", Handler: _Backup_Backup_Handler, ServerStreams: true, }, }, Metadata: "backup.proto", } // Client API for ExternalStorage service type ExternalStorageClient interface { // Restore to a file Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) // Save a file to storage Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) } type externalStorageClient struct { cc *grpc.ClientConn } func NewExternalStorageClient(cc *grpc.ClientConn) ExternalStorageClient { return &externalStorageClient{cc} } func (c *externalStorageClient) Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) { out := new(ExternalStorageRestoreResponse) err := c.cc.Invoke(ctx, "/backup.ExternalStorage/restore", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *externalStorageClient) Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) { out := new(ExternalStorageSaveResponse) err := c.cc.Invoke(ctx, "/backup.ExternalStorage/save", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for ExternalStorage service type ExternalStorageServer interface { // Restore to a file Restore(context.Context, *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) // Save a file to storage Save(context.Context, *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) } func RegisterExternalStorageServer(s *grpc.Server, srv ExternalStorageServer) { s.RegisterService(&_ExternalStorage_serviceDesc, srv) } func _ExternalStorage_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExternalStorageRestoreRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ExternalStorageServer).Restore(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/backup.ExternalStorage/Restore", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ExternalStorageServer).Restore(ctx, req.(*ExternalStorageRestoreRequest)) } return interceptor(ctx, in, info, handler) } func _ExternalStorage_Save_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExternalStorageSaveRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ExternalStorageServer).Save(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/backup.ExternalStorage/Save", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ExternalStorageServer).Save(ctx, req.(*ExternalStorageSaveRequest)) } return interceptor(ctx, in, info, handler) } var _ExternalStorage_serviceDesc = grpc.ServiceDesc{ ServiceName: "backup.ExternalStorage", HandlerType: (*ExternalStorageServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "restore", Handler: _ExternalStorage_Restore_Handler, }, { MethodName: "save", Handler: _ExternalStorage_Save_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "backup.proto", } func (m *BackupMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBackup(dAtA, i, uint64(m.ClusterId)) } if len(m.ClusterVersion) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.ClusterVersion))) i += copy(dAtA[i:], m.ClusterVersion) } if len(m.Files) > 0 { for _, msg := range m.Files { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.StartVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBackup(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBackup(dAtA, i, uint64(m.EndVersion)) } if len(m.Schemas) > 0 { for _, msg := range m.Schemas { dAtA[i] = 0x3a i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.IsRawKv { dAtA[i] = 0x40 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.RawRanges) > 0 { for _, msg := range m.RawRanges { dAtA[i] = 0x4a i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Ddls) > 0 { dAtA[i] = 0x52 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Ddls))) i += copy(dAtA[i:], m.Ddls) } if len(m.BrVersion) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.BrVersion))) i += copy(dAtA[i:], m.BrVersion) } if m.Version != 0 { dAtA[i] = 0x60 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Version)) } if m.FileIndex != nil { dAtA[i] = 0x6a i++ i = encodeVarintBackup(dAtA, i, uint64(m.FileIndex.Size())) n1, err := m.FileIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.SchemaIndex != nil { dAtA[i] = 0x72 i++ i = encodeVarintBackup(dAtA, i, uint64(m.SchemaIndex.Size())) n2, err := m.SchemaIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.RawRangeIndex != nil { dAtA[i] = 0x7a i++ i = encodeVarintBackup(dAtA, i, uint64(m.RawRangeIndex.Size())) n3, err := m.RawRangeIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.DdlIndexes != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintBackup(dAtA, i, uint64(m.DdlIndexes.Size())) n4, err := m.DdlIndexes.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *File) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *File) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Sha256) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Sha256))) i += copy(dAtA[i:], m.Sha256) } if len(m.StartKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.StartVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBackup(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBackup(dAtA, i, uint64(m.EndVersion)) } if m.Crc64Xor != 0 { dAtA[i] = 0x38 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { dAtA[i] = 0x40 i++ i = encodeVarintBackup(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x48 i++ i = encodeVarintBackup(dAtA, i, uint64(m.TotalBytes)) } if len(m.Cf) > 0 { dAtA[i] = 0x52 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Size_ != 0 { dAtA[i] = 0x58 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Size_)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MetaFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MetaFile) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.MetaFiles) > 0 { for _, msg := range m.MetaFiles { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.DataFiles) > 0 { for _, msg := range m.DataFiles { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Schemas) > 0 { for _, msg := range m.Schemas { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.RawRanges) > 0 { for _, msg := range m.RawRanges { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Ddls) > 0 { for _, b := range m.Ddls { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Schema) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Schema) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Db) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Db))) i += copy(dAtA[i:], m.Db) } if len(m.Table) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Table))) i += copy(dAtA[i:], m.Table) } if m.Crc64Xor != 0 { dAtA[i] = 0x18 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBackup(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBackup(dAtA, i, uint64(m.TotalBytes)) } if m.TiflashReplicas != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBackup(dAtA, i, uint64(m.TiflashReplicas)) } if len(m.Stats) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Stats))) i += copy(dAtA[i:], m.Stats) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawRange) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.StartKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ClusterIDError) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ClusterIDError) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Current != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Current)) } if m.Request != 0 { dAtA[i] = 0x10 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Request)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Msg) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Msg))) i += copy(dAtA[i:], m.Msg) } if m.Detail != nil { nn5, err := m.Detail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn5 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error_ClusterIdError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ClusterIdError != nil { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(m.ClusterIdError.Size())) n6, err := m.ClusterIdError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } return i, nil } func (m *Error_KvError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.KvError != nil { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(m.KvError.Size())) n7, err := m.KvError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } return i, nil } func (m *Error_RegionError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RegionError != nil { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(m.RegionError.Size())) n8, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } return i, nil } func (m *BackupRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBackup(dAtA, i, uint64(m.ClusterId)) } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.StartVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBackup(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBackup(dAtA, i, uint64(m.EndVersion)) } if m.RateLimit != 0 { dAtA[i] = 0x38 i++ i = encodeVarintBackup(dAtA, i, uint64(m.RateLimit)) } if m.Concurrency != 0 { dAtA[i] = 0x40 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Concurrency)) } if m.StorageBackend != nil { dAtA[i] = 0x4a i++ i = encodeVarintBackup(dAtA, i, uint64(m.StorageBackend.Size())) n9, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.IsRawKv { dAtA[i] = 0x50 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Cf) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.CompressionType != 0 { dAtA[i] = 0x60 i++ i = encodeVarintBackup(dAtA, i, uint64(m.CompressionType)) } if m.CompressionLevel != 0 { dAtA[i] = 0x68 i++ i = encodeVarintBackup(dAtA, i, uint64(m.CompressionLevel)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StorageBackend) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StorageBackend) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Backend != nil { nn10, err := m.Backend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn10 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StorageBackend_Noop) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Noop != nil { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(m.Noop.Size())) n11, err := m.Noop.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } return i, nil } func (m *StorageBackend_Local) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Local != nil { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Local.Size())) n12, err := m.Local.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } return i, nil } func (m *StorageBackend_S3) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.S3 != nil { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(m.S3.Size())) n13, err := m.S3.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } return i, nil } func (m *StorageBackend_Gcs) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Gcs != nil { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(m.Gcs.Size())) n14, err := m.Gcs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } return i, nil } func (m *StorageBackend_CloudDynamic) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CloudDynamic != nil { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(m.CloudDynamic.Size())) n15, err := m.CloudDynamic.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } return i, nil } func (m *Noop) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Noop) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Local) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Local) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Path) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Path))) i += copy(dAtA[i:], m.Path) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *S3) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *S3) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Region) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Region))) i += copy(dAtA[i:], m.Region) } if len(m.Bucket) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if len(m.Sse) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Sse))) i += copy(dAtA[i:], m.Sse) } if len(m.Acl) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Acl))) i += copy(dAtA[i:], m.Acl) } if len(m.AccessKey) > 0 { dAtA[i] = 0x42 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.AccessKey))) i += copy(dAtA[i:], m.AccessKey) } if len(m.SecretAccessKey) > 0 { dAtA[i] = 0x4a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.SecretAccessKey))) i += copy(dAtA[i:], m.SecretAccessKey) } if m.ForcePathStyle { dAtA[i] = 0x50 i++ if m.ForcePathStyle { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.SseKmsKeyId) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.SseKmsKeyId))) i += copy(dAtA[i:], m.SseKmsKeyId) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GCS) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GCS) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Bucket) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if len(m.PredefinedAcl) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.PredefinedAcl))) i += copy(dAtA[i:], m.PredefinedAcl) } if len(m.CredentialsBlob) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.CredentialsBlob))) i += copy(dAtA[i:], m.CredentialsBlob) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Bucket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Bucket) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Region) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Region))) i += copy(dAtA[i:], m.Region) } if len(m.Bucket) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CloudDynamic) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CloudDynamic) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Bucket != nil { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(m.Bucket.Size())) n16, err := m.Bucket.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if len(m.ProviderName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.ProviderName))) i += copy(dAtA[i:], m.ProviderName) } if len(m.Attrs) > 0 { for k, _ := range m.Attrs { dAtA[i] = 0x1a i++ v := m.Attrs[k] mapSize := 1 + len(k) + sovBackup(uint64(len(k))) + 1 + len(v) + sovBackup(uint64(len(v))) i = encodeVarintBackup(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(len(k))) i += copy(dAtA[i:], k) dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(v))) i += copy(dAtA[i:], v) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BackupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(m.Error.Size())) n17, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if len(m.Files) > 0 { for _, msg := range m.Files { dAtA[i] = 0x22 i++ i = encodeVarintBackup(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageRestoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageRestoreRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StorageBackend != nil { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(m.StorageBackend.Size())) n18, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if len(m.ObjectName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.ObjectName))) i += copy(dAtA[i:], m.ObjectName) } if len(m.RestoreName) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.RestoreName))) i += copy(dAtA[i:], m.RestoreName) } if m.ContentLength != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBackup(dAtA, i, uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageRestoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageRestoreResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageSaveRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageSaveRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StorageBackend != nil { dAtA[i] = 0xa i++ i = encodeVarintBackup(dAtA, i, uint64(m.StorageBackend.Size())) n19, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if len(m.ObjectName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBackup(dAtA, i, uint64(len(m.ObjectName))) i += copy(dAtA[i:], m.ObjectName) } if m.ContentLength != 0 { dAtA[i] = 0x18 i++ i = encodeVarintBackup(dAtA, i, uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageSaveResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageSaveResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintBackup(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *BackupMeta) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovBackup(uint64(m.ClusterId)) } l = len(m.ClusterVersion) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if len(m.Files) > 0 { for _, e := range m.Files { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if m.StartVersion != 0 { n += 1 + sovBackup(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBackup(uint64(m.EndVersion)) } if len(m.Schemas) > 0 { for _, e := range m.Schemas { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if m.IsRawKv { n += 2 } if len(m.RawRanges) > 0 { for _, e := range m.RawRanges { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } l = len(m.Ddls) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.BrVersion) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.Version != 0 { n += 1 + sovBackup(uint64(m.Version)) } if m.FileIndex != nil { l = m.FileIndex.Size() n += 1 + l + sovBackup(uint64(l)) } if m.SchemaIndex != nil { l = m.SchemaIndex.Size() n += 1 + l + sovBackup(uint64(l)) } if m.RawRangeIndex != nil { l = m.RawRangeIndex.Size() n += 1 + l + sovBackup(uint64(l)) } if m.DdlIndexes != nil { l = m.DdlIndexes.Size() n += 2 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *File) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Sha256) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovBackup(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBackup(uint64(m.EndVersion)) } if m.Crc64Xor != 0 { n += 1 + sovBackup(uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { n += 1 + sovBackup(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovBackup(uint64(m.TotalBytes)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.Size_ != 0 { n += 1 + sovBackup(uint64(m.Size_)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MetaFile) Size() (n int) { var l int _ = l if len(m.MetaFiles) > 0 { for _, e := range m.MetaFiles { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if len(m.DataFiles) > 0 { for _, e := range m.DataFiles { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if len(m.Schemas) > 0 { for _, e := range m.Schemas { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if len(m.RawRanges) > 0 { for _, e := range m.RawRanges { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if len(m.Ddls) > 0 { for _, b := range m.Ddls { l = len(b) n += 1 + l + sovBackup(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Schema) Size() (n int) { var l int _ = l l = len(m.Db) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Table) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.Crc64Xor != 0 { n += 1 + sovBackup(uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { n += 1 + sovBackup(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovBackup(uint64(m.TotalBytes)) } if m.TiflashReplicas != 0 { n += 1 + sovBackup(uint64(m.TiflashReplicas)) } l = len(m.Stats) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawRange) Size() (n int) { var l int _ = l l = len(m.StartKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ClusterIDError) Size() (n int) { var l int _ = l if m.Current != 0 { n += 1 + sovBackup(uint64(m.Current)) } if m.Request != 0 { n += 1 + sovBackup(uint64(m.Request)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l l = len(m.Msg) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.Detail != nil { n += m.Detail.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error_ClusterIdError) Size() (n int) { var l int _ = l if m.ClusterIdError != nil { l = m.ClusterIdError.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *Error_KvError) Size() (n int) { var l int _ = l if m.KvError != nil { l = m.KvError.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *Error_RegionError) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *BackupRequest) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovBackup(uint64(m.ClusterId)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovBackup(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBackup(uint64(m.EndVersion)) } if m.RateLimit != 0 { n += 1 + sovBackup(uint64(m.RateLimit)) } if m.Concurrency != 0 { n += 1 + sovBackup(uint64(m.Concurrency)) } if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBackup(uint64(l)) } if m.IsRawKv { n += 2 } l = len(m.Cf) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.CompressionType != 0 { n += 1 + sovBackup(uint64(m.CompressionType)) } if m.CompressionLevel != 0 { n += 1 + sovBackup(uint64(m.CompressionLevel)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StorageBackend) Size() (n int) { var l int _ = l if m.Backend != nil { n += m.Backend.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StorageBackend_Noop) Size() (n int) { var l int _ = l if m.Noop != nil { l = m.Noop.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *StorageBackend_Local) Size() (n int) { var l int _ = l if m.Local != nil { l = m.Local.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *StorageBackend_S3) Size() (n int) { var l int _ = l if m.S3 != nil { l = m.S3.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *StorageBackend_Gcs) Size() (n int) { var l int _ = l if m.Gcs != nil { l = m.Gcs.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *StorageBackend_CloudDynamic) Size() (n int) { var l int _ = l if m.CloudDynamic != nil { l = m.CloudDynamic.Size() n += 1 + l + sovBackup(uint64(l)) } return n } func (m *Noop) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Local) Size() (n int) { var l int _ = l l = len(m.Path) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *S3) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Region) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Sse) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Acl) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.AccessKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.SecretAccessKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.ForcePathStyle { n += 2 } l = len(m.SseKmsKeyId) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GCS) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.PredefinedAcl) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.CredentialsBlob) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Bucket) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Region) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CloudDynamic) Size() (n int) { var l int _ = l if m.Bucket != nil { l = m.Bucket.Size() n += 1 + l + sovBackup(uint64(l)) } l = len(m.ProviderName) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if len(m.Attrs) > 0 { for k, v := range m.Attrs { _ = k _ = v mapEntrySize := 1 + len(k) + sovBackup(uint64(len(k))) + 1 + len(v) + sovBackup(uint64(len(v))) n += mapEntrySize + 1 + sovBackup(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BackupResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovBackup(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if len(m.Files) > 0 { for _, e := range m.Files { l = e.Size() n += 1 + l + sovBackup(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageRestoreRequest) Size() (n int) { var l int _ = l if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBackup(uint64(l)) } l = len(m.ObjectName) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } l = len(m.RestoreName) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.ContentLength != 0 { n += 1 + sovBackup(uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageRestoreResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageSaveRequest) Size() (n int) { var l int _ = l if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBackup(uint64(l)) } l = len(m.ObjectName) if l > 0 { n += 1 + l + sovBackup(uint64(l)) } if m.ContentLength != 0 { n += 1 + sovBackup(uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageSaveResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovBackup(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozBackup(x uint64) (n int) { return sovBackup(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *BackupMeta) 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 ErrIntOverflowBackup } 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: BackupMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ClusterVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Files = append(m.Files, &File{}) if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Schemas = append(m.Schemas, &Schema{}) if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RawRanges = append(m.RawRanges, &RawRange{}) if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Ddls = append(m.Ddls[:0], dAtA[iNdEx:postIndex]...) if m.Ddls == nil { m.Ddls = []byte{} } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BrVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.BrVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FileIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.FileIndex == nil { m.FileIndex = &MetaFile{} } if err := m.FileIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SchemaIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.SchemaIndex == nil { m.SchemaIndex = &MetaFile{} } if err := m.SchemaIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawRangeIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RawRangeIndex == nil { m.RawRangeIndex = &MetaFile{} } if err := m.RawRangeIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DdlIndexes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DdlIndexes == nil { m.DdlIndexes = &MetaFile{} } if err := m.DdlIndexes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *File) 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 ErrIntOverflowBackup } 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: File: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: File: 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 ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen 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 Sha256", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) if m.Sha256 == nil { m.Sha256 = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc64Xor |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 11: 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 ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *MetaFile) 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 ErrIntOverflowBackup } 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: MetaFile: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MetaFile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MetaFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.MetaFiles = append(m.MetaFiles, &File{}) if err := m.MetaFiles[len(m.MetaFiles)-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 DataFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.DataFiles = append(m.DataFiles, &File{}) if err := m.DataFiles[len(m.DataFiles)-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 Schemas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Schemas = append(m.Schemas, &Schema{}) if err := m.Schemas[len(m.Schemas)-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 RawRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RawRanges = append(m.RawRanges, &RawRange{}) if err := m.RawRanges[len(m.RawRanges)-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 Ddls", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Ddls = append(m.Ddls, make([]byte, postIndex-iNdEx)) copy(m.Ddls[len(m.Ddls)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *Schema) 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 ErrIntOverflowBackup } 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: Schema: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Schema: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Db = append(m.Db[:0], dAtA[iNdEx:postIndex]...) if m.Db == nil { m.Db = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Table = append(m.Table[:0], dAtA[iNdEx:postIndex]...) if m.Table == nil { m.Table = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc64Xor |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TiflashReplicas", wireType) } m.TiflashReplicas = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TiflashReplicas |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Stats = append(m.Stats[:0], dAtA[iNdEx:postIndex]...) if m.Stats == nil { m.Stats = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *RawRange) 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 ErrIntOverflowBackup } 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: RawRange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *ClusterIDError) 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 ErrIntOverflowBackup } 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: ClusterIDError: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ClusterIDError: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) } m.Current = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Current |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } m.Request = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Request |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *Error) 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 ErrIntOverflowBackup } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Msg = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &ClusterIDError{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_ClusterIdError{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KvError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.KeyError{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_KvError{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &errorpb.Error{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_RegionError{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *BackupRequest) 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 ErrIntOverflowBackup } 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: BackupRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RateLimit", wireType) } m.RateLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RateLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType) } m.Concurrency = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Concurrency |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) } m.CompressionType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompressionType |= (CompressionType(b) & 0x7F) << shift if b < 0x80 { break } } case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompressionLevel", wireType) } m.CompressionLevel = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompressionLevel |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *StorageBackend) 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 ErrIntOverflowBackup } 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: StorageBackend: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StorageBackend: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Noop", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Noop{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Noop{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Local{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Local{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S3", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &S3{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_S3{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Gcs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &GCS{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Gcs{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CloudDynamic", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &CloudDynamic{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_CloudDynamic{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *Noop) 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 ErrIntOverflowBackup } 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: Noop: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Noop: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *Local) 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 ErrIntOverflowBackup } 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: Local: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Local: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *S3) 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 ErrIntOverflowBackup } 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: S3: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: S3: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sse", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Sse = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Acl", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Acl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.AccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SecretAccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForcePathStyle", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForcePathStyle = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SseKmsKeyId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SseKmsKeyId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *GCS) 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 ErrIntOverflowBackup } 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: GCS: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GCS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PredefinedAcl", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PredefinedAcl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CredentialsBlob", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.CredentialsBlob = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *Bucket) 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 ErrIntOverflowBackup } 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: Bucket: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Bucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *CloudDynamic) 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 ErrIntOverflowBackup } 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: CloudDynamic: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CloudDynamic: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Bucket == nil { m.Bucket = &Bucket{} } if err := m.Bucket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ProviderName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Attrs == nil { m.Attrs = 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 ErrIntOverflowBackup } 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 ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postStringIndexmapkey := iNdEx + intStringLenmapkey 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 ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Attrs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *BackupResponse) 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 ErrIntOverflowBackup } 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: BackupResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Files = append(m.Files, &File{}) if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *ExternalStorageRestoreRequest) 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 ErrIntOverflowBackup } 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: ExternalStorageRestoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageRestoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RestoreName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.RestoreName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContentLength |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *ExternalStorageRestoreResponse) 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 ErrIntOverflowBackup } 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: ExternalStorageRestoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageRestoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *ExternalStorageSaveRequest) 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 ErrIntOverflowBackup } 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: ExternalStorageSaveRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageSaveRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBackup } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } 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 ErrInvalidLengthBackup } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBackup } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContentLength |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 *ExternalStorageSaveResponse) 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 ErrIntOverflowBackup } 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: ExternalStorageSaveResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageSaveResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBackup(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBackup } 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 skipBackup(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBackup } 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, ErrIntOverflowBackup } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBackup } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthBackup } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBackup } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipBackup(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthBackup = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowBackup = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("backup.proto", fileDescriptor_backup_c0317208fdb49464) } var fileDescriptor_backup_c0317208fdb49464 = []byte{ // 1729 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5f, 0x8f, 0x1b, 0x49, 0x11, 0xf7, 0x78, 0xc6, 0x7f, 0xa6, 0xfc, 0x37, 0xad, 0x90, 0xb3, 0x1c, 0xb2, 0x31, 0x13, 0x25, 0x2c, 0x77, 0xd2, 0x1e, 0xec, 0xde, 0x9d, 0x22, 0x4e, 0x08, 0xc5, 0x49, 0xb8, 0xdd, 0xdb, 0x65, 0x09, 0xed, 0x03, 0x44, 0x5e, 0x46, 0xed, 0x99, 0x5e, 0xef, 0xe0, 0xf1, 0x8c, 0x99, 0x6e, 0x3b, 0x31, 0x5f, 0x02, 0xf1, 0xc6, 0x17, 0x40, 0xe2, 0x81, 0x0f, 0xc1, 0xe3, 0xa1, 0xe3, 0x01, 0x09, 0x21, 0xf1, 0x08, 0xe1, 0x8b, 0xa0, 0xea, 0xee, 0x99, 0xb5, 0x93, 0xb5, 0x13, 0x10, 0xe2, 0x69, 0xbb, 0x7f, 0x55, 0xd5, 0xdd, 0x55, 0xf5, 0xab, 0xaa, 0xf1, 0x42, 0x73, 0xcc, 0x82, 0xe9, 0x62, 0x7e, 0x30, 0xcf, 0x52, 0x99, 0x92, 0xaa, 0xde, 0xf5, 0x5b, 0xd3, 0x65, 0x36, 0x0f, 0xe6, 0x63, 0x0d, 0xf7, 0x5b, 0x3c, 0xcb, 0xd2, 0xac, 0xd8, 0xde, 0x9c, 0xa4, 0x93, 0x54, 0x2d, 0x3f, 0xc4, 0x95, 0x41, 0x3b, 0xd9, 0x42, 0x48, 0xb5, 0xd4, 0x80, 0xf7, 0x4f, 0x07, 0x60, 0xa8, 0xce, 0xfb, 0x21, 0x97, 0x8c, 0xdc, 0x01, 0x08, 0xe2, 0x85, 0x90, 0x3c, 0xf3, 0xa3, 0xb0, 0x67, 0x0d, 0xac, 0x7d, 0x87, 0xba, 0x06, 0x39, 0x09, 0xc9, 0x37, 0xa1, 0x93, 0x8b, 0x97, 0x3c, 0x13, 0x51, 0x9a, 0xf4, 0xca, 0x03, 0x6b, 0xdf, 0xa5, 0x6d, 0x03, 0xff, 0x54, 0xa3, 0xc4, 0x83, 0xca, 0x45, 0x14, 0x73, 0xd1, 0x73, 0x06, 0xf6, 0x7e, 0xe3, 0xb0, 0x79, 0x60, 0x3c, 0xf8, 0x41, 0x14, 0x73, 0xaa, 0x45, 0xe4, 0x1e, 0xb4, 0x84, 0x64, 0x99, 0x2c, 0x8e, 0xaa, 0xa8, 0xeb, 0x9a, 0x0a, 0xcc, 0x0f, 0xba, 0x0b, 0x0d, 0x9e, 0x84, 0x85, 0x4a, 0x55, 0xa9, 0x00, 0x4f, 0xc2, 0x5c, 0x61, 0x1f, 0x6a, 0x22, 0xb8, 0xe4, 0x33, 0x26, 0x7a, 0x35, 0x75, 0x57, 0x3b, 0xbf, 0x6b, 0xa4, 0x60, 0x9a, 0x8b, 0x49, 0x1f, 0xdc, 0x48, 0xf8, 0x19, 0x7b, 0xe1, 0x4f, 0x97, 0xbd, 0xfa, 0xc0, 0xda, 0xaf, 0xd3, 0x5a, 0x24, 0x28, 0x7b, 0x71, 0xba, 0x24, 0x1f, 0x02, 0xa0, 0x20, 0x63, 0xc9, 0x84, 0x8b, 0x9e, 0xab, 0x0e, 0xea, 0xe6, 0x07, 0x51, 0xf6, 0x82, 0xa2, 0x80, 0xba, 0x99, 0x59, 0x09, 0x42, 0xc0, 0x09, 0xc3, 0x58, 0xf4, 0x60, 0x60, 0xed, 0x37, 0xa9, 0x5a, 0x63, 0xf0, 0xc6, 0x57, 0x81, 0x69, 0xa8, 0xc0, 0xb8, 0xe3, 0x22, 0x26, 0x3d, 0xa8, 0xe5, 0xb2, 0xe6, 0xc0, 0xda, 0xaf, 0xd0, 0x7c, 0x8b, 0xb7, 0x63, 0x48, 0xfc, 0x28, 0x09, 0xf9, 0xcb, 0x5e, 0x6b, 0x60, 0xad, 0xdf, 0x8e, 0x79, 0x51, 0x61, 0x73, 0x51, 0xe7, 0x04, 0x55, 0xc8, 0x11, 0x34, 0xb5, 0x57, 0xc6, 0xa4, 0xbd, 0xc5, 0xa4, 0xa1, 0xb5, 0xb4, 0xd1, 0x43, 0xe8, 0x14, 0x3e, 0x1a, 0xbb, 0xce, 0x16, 0xbb, 0x56, 0xee, 0xa8, 0xb6, 0xfc, 0x0e, 0x34, 0xc2, 0x30, 0xd6, 0x36, 0x5c, 0xf4, 0xba, 0x5b, 0xac, 0x20, 0x0c, 0xe3, 0x13, 0xad, 0xf3, 0xb9, 0x53, 0xb7, 0xbb, 0x0e, 0x75, 0xe6, 0x4c, 0x5e, 0x7a, 0x7f, 0x28, 0x83, 0x83, 0x0a, 0x18, 0xb4, 0x84, 0xcd, 0xb8, 0xe2, 0x95, 0x4b, 0xd5, 0x9a, 0xdc, 0x82, 0xaa, 0xb8, 0x64, 0x87, 0x1f, 0x7f, 0xa2, 0x98, 0xd4, 0xa4, 0x66, 0x47, 0x6e, 0x83, 0xab, 0xd9, 0x31, 0xe5, 0xab, 0x9e, 0xad, 0x44, 0x75, 0x05, 0x9c, 0xf2, 0x15, 0x79, 0x0f, 0x6a, 0xc8, 0x0a, 0x14, 0x39, 0xda, 0x8a, 0x27, 0x21, 0x0a, 0xfe, 0x37, 0x9c, 0xea, 0x43, 0x3d, 0xc8, 0x82, 0x4f, 0x3e, 0x7a, 0x99, 0x66, 0xbd, 0x9a, 0x92, 0x16, 0x7b, 0x7c, 0x97, 0x4c, 0x25, 0x8b, 0xfd, 0xe9, 0x52, 0x28, 0x16, 0x39, 0xb4, 0xae, 0x80, 0xd3, 0xa5, 0xc0, 0x93, 0xb5, 0x70, 0xbc, 0x92, 0x8a, 0x47, 0xea, 0x64, 0x05, 0x0d, 0x11, 0x21, 0x6d, 0x28, 0x07, 0x17, 0x8a, 0x34, 0x2e, 0x2d, 0x07, 0x17, 0x18, 0x11, 0x11, 0xfd, 0x8a, 0x2b, 0xb2, 0x38, 0x54, 0xad, 0xbd, 0xbf, 0x5a, 0x50, 0xcf, 0x63, 0x4a, 0x3e, 0x00, 0x98, 0x71, 0xc9, 0x7c, 0x5d, 0x4d, 0xd6, 0x35, 0xd5, 0xe4, 0xce, 0x8c, 0xae, 0x40, 0xe5, 0x90, 0x15, 0xca, 0xe5, 0xeb, 0x94, 0x51, 0xae, 0x95, 0xd7, 0x0a, 0xc7, 0xde, 0x5d, 0x38, 0x9b, 0xc5, 0xe1, 0xbc, 0x7b, 0x71, 0x54, 0x06, 0x76, 0x5e, 0x1c, 0xde, 0x9f, 0x2c, 0xa8, 0xea, 0x83, 0x31, 0x08, 0xe1, 0x58, 0x91, 0xa0, 0x49, 0xcb, 0xe1, 0x98, 0xdc, 0x84, 0x8a, 0x64, 0xe3, 0x98, 0x1b, 0x06, 0xe8, 0xcd, 0x46, 0x12, 0xec, 0x5d, 0x49, 0x70, 0x76, 0x27, 0xa1, 0xf2, 0x46, 0x12, 0xbe, 0x05, 0x5d, 0x19, 0x5d, 0xc4, 0x4c, 0x5c, 0xfa, 0x19, 0x9f, 0xc7, 0x51, 0xc0, 0x84, 0x22, 0x41, 0x8b, 0x76, 0x0c, 0x4e, 0x0d, 0x8c, 0x4f, 0x13, 0x92, 0x49, 0xa1, 0x68, 0xd0, 0xa4, 0x7a, 0xe3, 0x3d, 0x83, 0x7a, 0xee, 0xf6, 0x26, 0x4f, 0xad, 0xed, 0x3c, 0x2d, 0x6f, 0xf0, 0x54, 0xf3, 0xc0, 0xce, 0x79, 0xe0, 0x3d, 0x81, 0xf6, 0x63, 0xd3, 0x65, 0x9f, 0x3c, 0xc5, 0x3e, 0x8e, 0xdd, 0x22, 0x58, 0x64, 0x19, 0x4f, 0xa4, 0x69, 0xc3, 0xf9, 0x16, 0x25, 0x19, 0xff, 0xe5, 0x82, 0x0b, 0xa9, 0x0e, 0x75, 0x68, 0xbe, 0xf5, 0xfe, 0x6c, 0x41, 0x45, 0x5b, 0x77, 0xc1, 0x9e, 0x89, 0x89, 0x29, 0x34, 0x5c, 0x92, 0x21, 0x74, 0xaf, 0x3a, 0xbb, 0xaf, 0x66, 0x85, 0xba, 0xbf, 0x71, 0x78, 0x2b, 0x4f, 0xe5, 0xe6, 0x0b, 0x8e, 0x4b, 0x45, 0x57, 0x3f, 0x09, 0xf5, 0xa9, 0x07, 0x50, 0x9f, 0x2e, 0x8d, 0xad, 0xa3, 0x6c, 0x6f, 0x1c, 0xe4, 0x43, 0xe8, 0x94, 0xaf, 0x72, 0xb3, 0xda, 0x74, 0xa9, 0xf5, 0x8f, 0xa0, 0x99, 0xf1, 0x49, 0x94, 0x26, 0xc6, 0xa6, 0xa2, 0x6c, 0xda, 0x07, 0xf9, 0xa4, 0xca, 0x0d, 0x1a, 0x5a, 0x4b, 0x6d, 0x87, 0x75, 0xa8, 0x86, 0x5c, 0xb2, 0x28, 0xf6, 0xfe, 0x66, 0x43, 0x4b, 0xcf, 0x26, 0xaa, 0x1d, 0x7c, 0xdb, 0x78, 0xda, 0xc8, 0x45, 0x79, 0x7b, 0x2e, 0xec, 0xdd, 0x3d, 0xc3, 0x79, 0x7b, 0xcf, 0xa8, 0xbc, 0xd1, 0x33, 0xee, 0x60, 0x91, 0x48, 0xee, 0xc7, 0xd1, 0x2c, 0x92, 0xa6, 0x6b, 0xb8, 0x88, 0x9c, 0x21, 0x40, 0x06, 0xd0, 0x08, 0xd2, 0x44, 0xa7, 0x30, 0x58, 0xa9, 0xc6, 0xd1, 0xa2, 0xeb, 0x10, 0xf9, 0x3e, 0x74, 0x84, 0x4c, 0x33, 0x36, 0xe1, 0x3e, 0xe6, 0x83, 0x27, 0xa1, 0xea, 0x1f, 0x6b, 0xf9, 0x19, 0x69, 0xf1, 0x50, 0x4b, 0x69, 0x5b, 0x6c, 0xec, 0x37, 0xe7, 0x1b, 0x6c, 0xce, 0x37, 0xcd, 0xb7, 0x46, 0xd1, 0x77, 0x90, 0x0d, 0xe9, 0x6c, 0x9e, 0x71, 0x81, 0x8f, 0xf7, 0xe5, 0x6a, 0xce, 0xd5, 0x50, 0x6a, 0x1f, 0xbe, 0x57, 0xb0, 0xe1, 0x4a, 0xfe, 0xc5, 0x6a, 0xce, 0x69, 0x27, 0xd8, 0x04, 0xc8, 0x07, 0x70, 0x63, 0xfd, 0x8c, 0x98, 0x2f, 0x79, 0xac, 0x86, 0x57, 0x85, 0xae, 0x1f, 0x7e, 0x86, 0xf8, 0xe7, 0x4e, 0xbd, 0xda, 0xad, 0x99, 0x79, 0xf0, 0xca, 0x82, 0xf6, 0xa6, 0x2f, 0xc4, 0x03, 0x27, 0x49, 0xd3, 0xb9, 0x4a, 0xe9, 0x5a, 0xcf, 0x3a, 0x4f, 0xd3, 0xf9, 0x71, 0x89, 0x2a, 0x19, 0xb9, 0x0f, 0x95, 0x38, 0x0d, 0x58, 0xac, 0x32, 0xdb, 0x38, 0x6c, 0xe5, 0x4a, 0x67, 0x08, 0x1e, 0x97, 0xa8, 0x96, 0x92, 0xaf, 0x43, 0x59, 0x1c, 0x19, 0x6a, 0x43, 0x11, 0xba, 0xa3, 0xe3, 0x12, 0x2d, 0x8b, 0x23, 0x72, 0x17, 0xec, 0x49, 0x20, 0x0c, 0x7b, 0x1b, 0xb9, 0xf8, 0xb3, 0xc7, 0xa3, 0xe3, 0x12, 0x45, 0x09, 0xf9, 0x14, 0x5a, 0x41, 0x9c, 0x2e, 0x42, 0x3f, 0x5c, 0x25, 0x6c, 0x16, 0x05, 0x86, 0xb4, 0x37, 0xaf, 0x8a, 0x24, 0x5d, 0x84, 0x4f, 0xb4, 0xec, 0xb8, 0x44, 0x9b, 0xc1, 0xda, 0x7e, 0xe8, 0x42, 0xcd, 0xe4, 0xce, 0xab, 0x82, 0x83, 0xaf, 0xf7, 0x6e, 0x43, 0x45, 0x3d, 0x10, 0x9b, 0x22, 0x7a, 0x9f, 0x0f, 0x3f, 0x15, 0x89, 0xaf, 0xca, 0x50, 0x1e, 0x1d, 0x61, 0xab, 0xe3, 0x49, 0x38, 0x4f, 0x23, 0x53, 0xec, 0x2e, 0x2d, 0xf6, 0x38, 0x1f, 0x75, 0x75, 0x98, 0x2f, 0x2d, 0xb3, 0x43, 0x7c, 0xbc, 0x08, 0xa6, 0x5c, 0x9a, 0x2e, 0x62, 0x76, 0x88, 0xcf, 0x33, 0x7e, 0x11, 0xbd, 0x54, 0x3e, 0xba, 0xd4, 0xec, 0x34, 0xcb, 0x35, 0xbd, 0x82, 0x98, 0x09, 0xdd, 0x17, 0x5d, 0x64, 0xb9, 0x02, 0x1f, 0x23, 0x86, 0x6d, 0x43, 0x08, 0xae, 0x9a, 0xa1, 0x4b, 0x71, 0x89, 0x08, 0x0b, 0x62, 0xc5, 0x67, 0x97, 0xe2, 0x12, 0x89, 0xce, 0x82, 0x80, 0x0b, 0xa1, 0x4a, 0xa9, 0xae, 0xbf, 0x72, 0x34, 0x82, 0xd5, 0xf4, 0x3e, 0xdc, 0x10, 0x3c, 0xc8, 0xb8, 0xf4, 0xd7, 0xb4, 0x5c, 0xa5, 0xd5, 0xd1, 0x82, 0x47, 0x85, 0xee, 0x3e, 0x74, 0x2f, 0xd2, 0x2c, 0xe0, 0x3e, 0x06, 0xc3, 0x17, 0x72, 0x15, 0x73, 0x43, 0xdc, 0xb6, 0xc2, 0x9f, 0x31, 0x79, 0x39, 0x42, 0x94, 0xdc, 0x83, 0xb6, 0x10, 0xdc, 0x9f, 0xce, 0xd4, 0x79, 0x58, 0xfc, 0x9a, 0xcb, 0x0d, 0x21, 0xf8, 0xe9, 0x0c, 0x0f, 0x3b, 0x09, 0xbd, 0x2f, 0x2d, 0xb0, 0x3f, 0x7b, 0x3c, 0x7a, 0x5b, 0x38, 0x4d, 0xd8, 0xca, 0x5b, 0xc2, 0x66, 0xef, 0x0e, 0x9b, 0x73, 0x4d, 0xd8, 0xee, 0x43, 0x7b, 0x9e, 0xf1, 0x90, 0x5f, 0x44, 0x09, 0x0f, 0x7d, 0x8c, 0x97, 0x0e, 0x6e, 0xeb, 0x0a, 0x7d, 0x14, 0xc4, 0x38, 0x77, 0x02, 0x04, 0x12, 0x19, 0xb1, 0x58, 0xf8, 0xe3, 0x38, 0x1d, 0x9b, 0x50, 0x77, 0xd6, 0xf0, 0x61, 0x9c, 0x8e, 0xbd, 0xdf, 0x58, 0x50, 0x1d, 0xea, 0x97, 0xbd, 0x1b, 0x39, 0xec, 0x2d, 0xe4, 0x70, 0xb6, 0x78, 0x59, 0xd9, 0xed, 0x65, 0xf5, 0x4d, 0x2f, 0x71, 0xba, 0x34, 0xd7, 0xd9, 0x4f, 0x1e, 0x14, 0xb7, 0x58, 0xa6, 0xb1, 0x9b, 0x1a, 0xd1, 0x2f, 0x2f, 0x6e, 0xbd, 0x07, 0xad, 0x79, 0x96, 0x2e, 0xa3, 0x90, 0x67, 0xbe, 0xfa, 0xfe, 0xd3, 0xa1, 0x6f, 0xe6, 0xe0, 0x39, 0x7e, 0x07, 0x7e, 0x0c, 0x15, 0x26, 0x65, 0x96, 0x7f, 0x8c, 0xdc, 0xbd, 0xae, 0xde, 0x0e, 0x1e, 0xa1, 0xc6, 0xd3, 0x44, 0x66, 0x2b, 0xaa, 0xb5, 0xfb, 0x0f, 0x01, 0xae, 0x40, 0x64, 0x6b, 0x3e, 0x86, 0x5d, 0x8a, 0x4b, 0x1c, 0xe0, 0x4b, 0x16, 0x2f, 0xf2, 0x3b, 0xf5, 0xe6, 0xbb, 0xe5, 0x87, 0x96, 0xf7, 0x6b, 0x0b, 0xda, 0xf9, 0x74, 0x11, 0xf3, 0x34, 0x11, 0xc8, 0xb2, 0x8a, 0x1e, 0x54, 0xd6, 0x66, 0x87, 0x51, 0x83, 0x89, 0x6a, 0xd9, 0x7f, 0x39, 0x64, 0xde, 0xe1, 0x07, 0x91, 0xf7, 0x95, 0x05, 0x77, 0x9e, 0xbe, 0x94, 0x3c, 0x4b, 0x58, 0x6c, 0xfa, 0x23, 0xe5, 0x98, 0x02, 0x9e, 0xcf, 0xbf, 0x6b, 0x66, 0x84, 0xf5, 0x1f, 0xcd, 0x88, 0xbb, 0xd0, 0x48, 0xc7, 0xbf, 0xe0, 0x81, 0x5c, 0x4f, 0x04, 0x68, 0x48, 0xa5, 0xe1, 0x1b, 0x38, 0xb2, 0xd5, 0x9d, 0x5a, 0x43, 0xf3, 0xaa, 0x61, 0x30, 0xa5, 0x72, 0x1f, 0xda, 0x41, 0x9a, 0x48, 0x9e, 0x48, 0x3f, 0xe6, 0xc9, 0x44, 0x5e, 0x9a, 0x81, 0xd9, 0x32, 0xe8, 0x99, 0x02, 0xbd, 0x01, 0xec, 0x6d, 0x73, 0x46, 0x87, 0xdb, 0xfb, 0x9d, 0x05, 0xfd, 0xd7, 0x54, 0x46, 0x6c, 0xf9, 0x7f, 0x74, 0xf6, 0x4d, 0x4f, 0xec, 0xeb, 0x3c, 0xb9, 0x03, 0xb7, 0xaf, 0x7d, 0xa6, 0x76, 0xe3, 0xfd, 0xef, 0x41, 0xe7, 0xb5, 0x59, 0x49, 0x1a, 0x50, 0xfb, 0xc9, 0xf9, 0xe9, 0xf9, 0x8f, 0x7e, 0x76, 0xde, 0x2d, 0x91, 0x1a, 0xd8, 0x67, 0xcf, 0x3f, 0xea, 0x5a, 0x04, 0xa0, 0x3a, 0x3a, 0x7f, 0xf4, 0xec, 0xd9, 0xcf, 0xbb, 0x65, 0x52, 0x07, 0xe7, 0xf9, 0xe8, 0x8b, 0x27, 0x5d, 0xfb, 0xf0, 0x29, 0x54, 0x35, 0x0d, 0xc9, 0xa7, 0x60, 0x7e, 0xda, 0x93, 0xaf, 0x15, 0x95, 0xb4, 0xfe, 0xf9, 0xd3, 0xbf, 0xf5, 0x3a, 0x6c, 0x02, 0x59, 0xfa, 0xb6, 0x75, 0xf8, 0x47, 0x0b, 0x3a, 0xaf, 0xbd, 0x92, 0x3c, 0xc7, 0x2f, 0x45, 0x15, 0x73, 0x72, 0xbf, 0xe0, 0xf2, 0x2e, 0x82, 0xf5, 0x1f, 0xbc, 0x4d, 0x2d, 0xbf, 0x91, 0xfc, 0x18, 0x1c, 0xc1, 0x96, 0x9c, 0x78, 0x5b, 0x2c, 0xd6, 0x32, 0xd9, 0xbf, 0xb7, 0x53, 0x27, 0x3f, 0x72, 0xf8, 0xe0, 0xef, 0xbf, 0xaf, 0x5b, 0x5f, 0xbe, 0xda, 0xb3, 0xfe, 0xf2, 0x6a, 0xcf, 0xfa, 0xc7, 0xab, 0x3d, 0xeb, 0xb7, 0xff, 0xda, 0x2b, 0x41, 0x37, 0xcd, 0x26, 0x07, 0x32, 0x9a, 0x2e, 0x0f, 0xa6, 0x4b, 0xf5, 0x3f, 0x8b, 0x71, 0x55, 0xfd, 0x39, 0xfa, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xfc, 0xdd, 0x1f, 0x17, 0x11, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/brpb/000077500000000000000000000000001421456440000160135ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/brpb/brpb.pb.go000066400000000000000000007122011421456440000176720ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: brpb.proto package backup import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" encryptionpb "github.com/pingcap/kvproto/pkg/encryptionpb" errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // sst files compression algorithm type CompressionType int32 const ( CompressionType_UNKNOWN CompressionType = 0 CompressionType_LZ4 CompressionType = 1 CompressionType_SNAPPY CompressionType = 2 CompressionType_ZSTD CompressionType = 3 ) var CompressionType_name = map[int32]string{ 0: "UNKNOWN", 1: "LZ4", 2: "SNAPPY", 3: "ZSTD", } var CompressionType_value = map[string]int32{ "UNKNOWN": 0, "LZ4": 1, "SNAPPY": 2, "ZSTD": 3, } func (x CompressionType) String() string { return proto.EnumName(CompressionType_name, int32(x)) } func (CompressionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{0} } // The message save the metadata of a backup. type BackupMeta struct { // ID and version of backuped cluster. ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` ClusterVersion string `protobuf:"bytes,2,opt,name=cluster_version,json=clusterVersion,proto3" json:"cluster_version,omitempty"` // Save the version of BR running backup jobs. BrVersion string `protobuf:"bytes,11,opt,name=br_version,json=brVersion,proto3" json:"br_version,omitempty"` // The backupmeta scheme version. Version int32 `protobuf:"varint,12,opt,name=version,proto3" json:"version,omitempty"` // A set of files that compose a backup. // Note: `files` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Files []*File `protobuf:"bytes,4,rep,name=files" json:"files,omitempty"` // An index to files contains data files. FileIndex *MetaFile `protobuf:"bytes,13,opt,name=file_index,json=fileIndex" json:"file_index,omitempty"` // A pair of timestamp specifies a time range of a backup. // For full backup, the start_version equals to the end_version, // it means point in time. // For incremental backup, the time range is specified as // (start_version, end_version]. StartVersion uint64 `protobuf:"varint,5,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,6,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` // Table metadata describes database and table info. // Note: `schemas` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Schemas []*Schema `protobuf:"bytes,7,rep,name=schemas" json:"schemas,omitempty"` // An index to files contains Schemas. SchemaIndex *MetaFile `protobuf:"bytes,14,opt,name=schema_index,json=schemaIndex" json:"schema_index,omitempty"` // If in raw kv mode, `start_versions`, `end_versions` and `schemas` will be // ignored, and the backup data's range is represented by raw_ranges. IsRawKv bool `protobuf:"varint,8,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. RawRanges []*RawRange `protobuf:"bytes,9,rep,name=raw_ranges,json=rawRanges" json:"raw_ranges,omitempty"` // An index to files contains RawRanges. RawRangeIndex *MetaFile `protobuf:"bytes,15,opt,name=raw_range_index,json=rawRangeIndex" json:"raw_range_index,omitempty"` // In incremental backup, DDLs which are completed in // (lastBackupTS, backupTS] will be stored here. // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. Ddls []byte `protobuf:"bytes,10,opt,name=ddls,proto3" json:"ddls,omitempty"` // An index to files contains DDLs. DdlIndexes *MetaFile `protobuf:"bytes,16,opt,name=ddl_indexes,json=ddlIndexes" json:"ddl_indexes,omitempty"` // the backup result into `backupmeta` file BackupResult string `protobuf:"bytes,17,opt,name=backup_result,json=backupResult,proto3" json:"backup_result,omitempty"` // API version implies the encode of the key and value. ApiVersion kvrpcpb.APIVersion `protobuf:"varint,18,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` // the placement policy info in backup cluster. we assume the policy won't be too much for one cluster. Policies []*PlacementPolicy `protobuf:"bytes,19,rep,name=policies" json:"policies,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupMeta) Reset() { *m = BackupMeta{} } func (m *BackupMeta) String() string { return proto.CompactTextString(m) } func (*BackupMeta) ProtoMessage() {} func (*BackupMeta) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{0} } func (m *BackupMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupMeta.Merge(dst, src) } func (m *BackupMeta) XXX_Size() int { return m.Size() } func (m *BackupMeta) XXX_DiscardUnknown() { xxx_messageInfo_BackupMeta.DiscardUnknown(m) } var xxx_messageInfo_BackupMeta proto.InternalMessageInfo func (m *BackupMeta) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *BackupMeta) GetClusterVersion() string { if m != nil { return m.ClusterVersion } return "" } func (m *BackupMeta) GetBrVersion() string { if m != nil { return m.BrVersion } return "" } func (m *BackupMeta) GetVersion() int32 { if m != nil { return m.Version } return 0 } func (m *BackupMeta) GetFiles() []*File { if m != nil { return m.Files } return nil } func (m *BackupMeta) GetFileIndex() *MetaFile { if m != nil { return m.FileIndex } return nil } func (m *BackupMeta) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *BackupMeta) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *BackupMeta) GetSchemas() []*Schema { if m != nil { return m.Schemas } return nil } func (m *BackupMeta) GetSchemaIndex() *MetaFile { if m != nil { return m.SchemaIndex } return nil } func (m *BackupMeta) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } func (m *BackupMeta) GetRawRanges() []*RawRange { if m != nil { return m.RawRanges } return nil } func (m *BackupMeta) GetRawRangeIndex() *MetaFile { if m != nil { return m.RawRangeIndex } return nil } func (m *BackupMeta) GetDdls() []byte { if m != nil { return m.Ddls } return nil } func (m *BackupMeta) GetDdlIndexes() *MetaFile { if m != nil { return m.DdlIndexes } return nil } func (m *BackupMeta) GetBackupResult() string { if m != nil { return m.BackupResult } return "" } func (m *BackupMeta) GetApiVersion() kvrpcpb.APIVersion { if m != nil { return m.ApiVersion } return kvrpcpb.APIVersion_V1 } func (m *BackupMeta) GetPolicies() []*PlacementPolicy { if m != nil { return m.Policies } return nil } type File struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Sha256 []byte `protobuf:"bytes,2,opt,name=sha256,proto3" json:"sha256,omitempty"` StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` StartVersion uint64 `protobuf:"varint,5,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,6,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` Crc64Xor uint64 `protobuf:"varint,7,opt,name=crc64xor,proto3" json:"crc64xor,omitempty"` TotalKvs uint64 `protobuf:"varint,8,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,9,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` Cf string `protobuf:"bytes,10,opt,name=cf,proto3" json:"cf,omitempty"` Size_ uint64 `protobuf:"varint,11,opt,name=size,proto3" json:"size,omitempty"` // cipher_iv is used for AES cipher CipherIv []byte `protobuf:"bytes,12,opt,name=cipher_iv,json=cipherIv,proto3" json:"cipher_iv,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *File) Reset() { *m = File{} } func (m *File) String() string { return proto.CompactTextString(m) } func (*File) ProtoMessage() {} func (*File) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{1} } func (m *File) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *File) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_File.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *File) XXX_Merge(src proto.Message) { xxx_messageInfo_File.Merge(dst, src) } func (m *File) XXX_Size() int { return m.Size() } func (m *File) XXX_DiscardUnknown() { xxx_messageInfo_File.DiscardUnknown(m) } var xxx_messageInfo_File proto.InternalMessageInfo func (m *File) GetName() string { if m != nil { return m.Name } return "" } func (m *File) GetSha256() []byte { if m != nil { return m.Sha256 } return nil } func (m *File) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *File) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *File) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *File) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *File) GetCrc64Xor() uint64 { if m != nil { return m.Crc64Xor } return 0 } func (m *File) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *File) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func (m *File) GetCf() string { if m != nil { return m.Cf } return "" } func (m *File) GetSize_() uint64 { if m != nil { return m.Size_ } return 0 } func (m *File) GetCipherIv() []byte { if m != nil { return m.CipherIv } return nil } // MetaFile describes a multi-level index of data used in backup. type MetaFile struct { // A set of files that contains a MetaFile. // It is used as a multi-level index. MetaFiles []*File `protobuf:"bytes,1,rep,name=meta_files,json=metaFiles" json:"meta_files,omitempty"` // A set of files that contains user data. DataFiles []*File `protobuf:"bytes,2,rep,name=data_files,json=dataFiles" json:"data_files,omitempty"` // A set of files that contains Schemas. Schemas []*Schema `protobuf:"bytes,3,rep,name=schemas" json:"schemas,omitempty"` // A set of files that contains RawRanges. RawRanges []*RawRange `protobuf:"bytes,4,rep,name=raw_ranges,json=rawRanges" json:"raw_ranges,omitempty"` // A set of files that contains DDLs. Ddls [][]byte `protobuf:"bytes,5,rep,name=ddls" json:"ddls,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MetaFile) Reset() { *m = MetaFile{} } func (m *MetaFile) String() string { return proto.CompactTextString(m) } func (*MetaFile) ProtoMessage() {} func (*MetaFile) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{2} } func (m *MetaFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MetaFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MetaFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MetaFile) XXX_Merge(src proto.Message) { xxx_messageInfo_MetaFile.Merge(dst, src) } func (m *MetaFile) XXX_Size() int { return m.Size() } func (m *MetaFile) XXX_DiscardUnknown() { xxx_messageInfo_MetaFile.DiscardUnknown(m) } var xxx_messageInfo_MetaFile proto.InternalMessageInfo func (m *MetaFile) GetMetaFiles() []*File { if m != nil { return m.MetaFiles } return nil } func (m *MetaFile) GetDataFiles() []*File { if m != nil { return m.DataFiles } return nil } func (m *MetaFile) GetSchemas() []*Schema { if m != nil { return m.Schemas } return nil } func (m *MetaFile) GetRawRanges() []*RawRange { if m != nil { return m.RawRanges } return nil } func (m *MetaFile) GetDdls() [][]byte { if m != nil { return m.Ddls } return nil } type PlacementPolicy struct { Info []byte `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PlacementPolicy) Reset() { *m = PlacementPolicy{} } func (m *PlacementPolicy) String() string { return proto.CompactTextString(m) } func (*PlacementPolicy) ProtoMessage() {} func (*PlacementPolicy) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{3} } func (m *PlacementPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PlacementPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PlacementPolicy.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PlacementPolicy) XXX_Merge(src proto.Message) { xxx_messageInfo_PlacementPolicy.Merge(dst, src) } func (m *PlacementPolicy) XXX_Size() int { return m.Size() } func (m *PlacementPolicy) XXX_DiscardUnknown() { xxx_messageInfo_PlacementPolicy.DiscardUnknown(m) } var xxx_messageInfo_PlacementPolicy proto.InternalMessageInfo func (m *PlacementPolicy) GetInfo() []byte { if m != nil { return m.Info } return nil } type Schema struct { Db []byte `protobuf:"bytes,1,opt,name=db,proto3" json:"db,omitempty"` Table []byte `protobuf:"bytes,2,opt,name=table,proto3" json:"table,omitempty"` Crc64Xor uint64 `protobuf:"varint,3,opt,name=crc64xor,proto3" json:"crc64xor,omitempty"` TotalKvs uint64 `protobuf:"varint,4,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` TiflashReplicas uint32 `protobuf:"varint,6,opt,name=tiflash_replicas,json=tiflashReplicas,proto3" json:"tiflash_replicas,omitempty"` // stats represents the dump stats for a analyzed table, which generate by DumpStatsToJSON // https://github.com/pingcap/tidb/blob/e136429d8dc5d70f43cd3f94179b0b9f47595097/statistics/handle/dump.go#L116 Stats []byte `protobuf:"bytes,7,opt,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Schema) Reset() { *m = Schema{} } func (m *Schema) String() string { return proto.CompactTextString(m) } func (*Schema) ProtoMessage() {} func (*Schema) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{4} } func (m *Schema) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Schema.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Schema) XXX_Merge(src proto.Message) { xxx_messageInfo_Schema.Merge(dst, src) } func (m *Schema) XXX_Size() int { return m.Size() } func (m *Schema) XXX_DiscardUnknown() { xxx_messageInfo_Schema.DiscardUnknown(m) } var xxx_messageInfo_Schema proto.InternalMessageInfo func (m *Schema) GetDb() []byte { if m != nil { return m.Db } return nil } func (m *Schema) GetTable() []byte { if m != nil { return m.Table } return nil } func (m *Schema) GetCrc64Xor() uint64 { if m != nil { return m.Crc64Xor } return 0 } func (m *Schema) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *Schema) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func (m *Schema) GetTiflashReplicas() uint32 { if m != nil { return m.TiflashReplicas } return 0 } func (m *Schema) GetStats() []byte { if m != nil { return m.Stats } return nil } type RawRange struct { StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawRange) Reset() { *m = RawRange{} } func (m *RawRange) String() string { return proto.CompactTextString(m) } func (*RawRange) ProtoMessage() {} func (*RawRange) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{5} } func (m *RawRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawRange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawRange) XXX_Merge(src proto.Message) { xxx_messageInfo_RawRange.Merge(dst, src) } func (m *RawRange) XXX_Size() int { return m.Size() } func (m *RawRange) XXX_DiscardUnknown() { xxx_messageInfo_RawRange.DiscardUnknown(m) } var xxx_messageInfo_RawRange proto.InternalMessageInfo func (m *RawRange) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *RawRange) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *RawRange) GetCf() string { if m != nil { return m.Cf } return "" } type ClusterIDError struct { Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"` Request uint64 `protobuf:"varint,2,opt,name=request,proto3" json:"request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ClusterIDError) Reset() { *m = ClusterIDError{} } func (m *ClusterIDError) String() string { return proto.CompactTextString(m) } func (*ClusterIDError) ProtoMessage() {} func (*ClusterIDError) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{6} } func (m *ClusterIDError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ClusterIDError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ClusterIDError.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ClusterIDError) XXX_Merge(src proto.Message) { xxx_messageInfo_ClusterIDError.Merge(dst, src) } func (m *ClusterIDError) XXX_Size() int { return m.Size() } func (m *ClusterIDError) XXX_DiscardUnknown() { xxx_messageInfo_ClusterIDError.DiscardUnknown(m) } var xxx_messageInfo_ClusterIDError proto.InternalMessageInfo func (m *ClusterIDError) GetCurrent() uint64 { if m != nil { return m.Current } return 0 } func (m *ClusterIDError) GetRequest() uint64 { if m != nil { return m.Request } return 0 } type Error struct { Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` // Types that are valid to be assigned to Detail: // *Error_ClusterIdError // *Error_KvError // *Error_RegionError Detail isError_Detail `protobuf_oneof:"detail"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{7} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo type isError_Detail interface { isError_Detail() MarshalTo([]byte) (int, error) Size() int } type Error_ClusterIdError struct { ClusterIdError *ClusterIDError `protobuf:"bytes,3,opt,name=cluster_id_error,json=clusterIdError,oneof"` } type Error_KvError struct { KvError *kvrpcpb.KeyError `protobuf:"bytes,4,opt,name=kv_error,json=kvError,oneof"` } type Error_RegionError struct { RegionError *errorpb.Error `protobuf:"bytes,5,opt,name=region_error,json=regionError,oneof"` } func (*Error_ClusterIdError) isError_Detail() {} func (*Error_KvError) isError_Detail() {} func (*Error_RegionError) isError_Detail() {} func (m *Error) GetDetail() isError_Detail { if m != nil { return m.Detail } return nil } func (m *Error) GetMsg() string { if m != nil { return m.Msg } return "" } func (m *Error) GetClusterIdError() *ClusterIDError { if x, ok := m.GetDetail().(*Error_ClusterIdError); ok { return x.ClusterIdError } return nil } func (m *Error) GetKvError() *kvrpcpb.KeyError { if x, ok := m.GetDetail().(*Error_KvError); ok { return x.KvError } return nil } func (m *Error) GetRegionError() *errorpb.Error { if x, ok := m.GetDetail().(*Error_RegionError); ok { return x.RegionError } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*Error) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _Error_OneofMarshaler, _Error_OneofUnmarshaler, _Error_OneofSizer, []interface{}{ (*Error_ClusterIdError)(nil), (*Error_KvError)(nil), (*Error_RegionError)(nil), } } func _Error_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Error) // detail switch x := m.Detail.(type) { case *Error_ClusterIdError: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ClusterIdError); err != nil { return err } case *Error_KvError: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.KvError); err != nil { return err } case *Error_RegionError: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RegionError); err != nil { return err } case nil: default: return fmt.Errorf("Error.Detail has unexpected type %T", x) } return nil } func _Error_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Error) switch tag { case 3: // detail.cluster_id_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(ClusterIDError) err := b.DecodeMessage(msg) m.Detail = &Error_ClusterIdError{msg} return true, err case 4: // detail.kv_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.KeyError) err := b.DecodeMessage(msg) m.Detail = &Error_KvError{msg} return true, err case 5: // detail.region_error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(errorpb.Error) err := b.DecodeMessage(msg) m.Detail = &Error_RegionError{msg} return true, err default: return false, nil } } func _Error_OneofSizer(msg proto.Message) (n int) { m := msg.(*Error) // detail switch x := m.Detail.(type) { case *Error_ClusterIdError: s := proto.Size(x.ClusterIdError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Error_KvError: s := proto.Size(x.KvError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Error_RegionError: s := proto.Size(x.RegionError) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type CipherInfo struct { CipherType encryptionpb.EncryptionMethod `protobuf:"varint,1,opt,name=cipher_type,json=cipherType,proto3,enum=encryptionpb.EncryptionMethod" json:"cipher_type,omitempty"` CipherKey []byte `protobuf:"bytes,2,opt,name=cipher_key,json=cipherKey,proto3" json:"cipher_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CipherInfo) Reset() { *m = CipherInfo{} } func (m *CipherInfo) String() string { return proto.CompactTextString(m) } func (*CipherInfo) ProtoMessage() {} func (*CipherInfo) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{8} } func (m *CipherInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CipherInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CipherInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CipherInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_CipherInfo.Merge(dst, src) } func (m *CipherInfo) XXX_Size() int { return m.Size() } func (m *CipherInfo) XXX_DiscardUnknown() { xxx_messageInfo_CipherInfo.DiscardUnknown(m) } var xxx_messageInfo_CipherInfo proto.InternalMessageInfo func (m *CipherInfo) GetCipherType() encryptionpb.EncryptionMethod { if m != nil { return m.CipherType } return encryptionpb.EncryptionMethod_UNKNOWN } func (m *CipherInfo) GetCipherKey() []byte { if m != nil { return m.CipherKey } return nil } type BackupRequest struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` EndVersion uint64 `protobuf:"varint,5,opt,name=end_version,json=endVersion,proto3" json:"end_version,omitempty"` // The I/O rate limit for backup request. RateLimit uint64 `protobuf:"varint,7,opt,name=rate_limit,json=rateLimit,proto3" json:"rate_limit,omitempty"` // The concurrency for executing the backup request in every tikv node. Concurrency uint32 `protobuf:"varint,8,opt,name=concurrency,proto3" json:"concurrency,omitempty"` StorageBackend *StorageBackend `protobuf:"bytes,9,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` // If raw kv mode is enabled, `start_version` and `end_version` will be ignored, and `cf` // specifies which cf to backup. IsRawKv bool `protobuf:"varint,10,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` Cf string `protobuf:"bytes,11,opt,name=cf,proto3" json:"cf,omitempty"` // algorithm used for compress sst files CompressionType CompressionType `protobuf:"varint,12,opt,name=compression_type,json=compressionType,proto3,enum=backup.CompressionType" json:"compression_type,omitempty"` // sst compression level, some algorithms support negative compression levels CompressionLevel int32 `protobuf:"varint,13,opt,name=compression_level,json=compressionLevel,proto3" json:"compression_level,omitempty"` // The cipher_info is Used to encrypt sst CipherInfo *CipherInfo `protobuf:"bytes,14,opt,name=cipher_info,json=cipherInfo" json:"cipher_info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupRequest) Reset() { *m = BackupRequest{} } func (m *BackupRequest) String() string { return proto.CompactTextString(m) } func (*BackupRequest) ProtoMessage() {} func (*BackupRequest) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{9} } func (m *BackupRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupRequest.Merge(dst, src) } func (m *BackupRequest) XXX_Size() int { return m.Size() } func (m *BackupRequest) XXX_DiscardUnknown() { xxx_messageInfo_BackupRequest.DiscardUnknown(m) } var xxx_messageInfo_BackupRequest proto.InternalMessageInfo func (m *BackupRequest) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *BackupRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *BackupRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *BackupRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *BackupRequest) GetEndVersion() uint64 { if m != nil { return m.EndVersion } return 0 } func (m *BackupRequest) GetRateLimit() uint64 { if m != nil { return m.RateLimit } return 0 } func (m *BackupRequest) GetConcurrency() uint32 { if m != nil { return m.Concurrency } return 0 } func (m *BackupRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *BackupRequest) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } func (m *BackupRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *BackupRequest) GetCompressionType() CompressionType { if m != nil { return m.CompressionType } return CompressionType_UNKNOWN } func (m *BackupRequest) GetCompressionLevel() int32 { if m != nil { return m.CompressionLevel } return 0 } func (m *BackupRequest) GetCipherInfo() *CipherInfo { if m != nil { return m.CipherInfo } return nil } type StorageBackend struct { // Types that are valid to be assigned to Backend: // *StorageBackend_Noop // *StorageBackend_Local // *StorageBackend_S3 // *StorageBackend_Gcs // *StorageBackend_CloudDynamic // *StorageBackend_Hdfs // *StorageBackend_AzureBlobStorage Backend isStorageBackend_Backend `protobuf_oneof:"backend"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StorageBackend) Reset() { *m = StorageBackend{} } func (m *StorageBackend) String() string { return proto.CompactTextString(m) } func (*StorageBackend) ProtoMessage() {} func (*StorageBackend) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{10} } func (m *StorageBackend) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StorageBackend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StorageBackend.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StorageBackend) XXX_Merge(src proto.Message) { xxx_messageInfo_StorageBackend.Merge(dst, src) } func (m *StorageBackend) XXX_Size() int { return m.Size() } func (m *StorageBackend) XXX_DiscardUnknown() { xxx_messageInfo_StorageBackend.DiscardUnknown(m) } var xxx_messageInfo_StorageBackend proto.InternalMessageInfo type isStorageBackend_Backend interface { isStorageBackend_Backend() MarshalTo([]byte) (int, error) Size() int } type StorageBackend_Noop struct { Noop *Noop `protobuf:"bytes,1,opt,name=noop,oneof"` } type StorageBackend_Local struct { Local *Local `protobuf:"bytes,2,opt,name=local,oneof"` } type StorageBackend_S3 struct { S3 *S3 `protobuf:"bytes,3,opt,name=s3,oneof"` } type StorageBackend_Gcs struct { Gcs *GCS `protobuf:"bytes,4,opt,name=gcs,oneof"` } type StorageBackend_CloudDynamic struct { CloudDynamic *CloudDynamic `protobuf:"bytes,5,opt,name=cloud_dynamic,json=cloudDynamic,oneof"` } type StorageBackend_Hdfs struct { Hdfs *HDFS `protobuf:"bytes,6,opt,name=hdfs,oneof"` } type StorageBackend_AzureBlobStorage struct { AzureBlobStorage *AzureBlobStorage `protobuf:"bytes,7,opt,name=azure_blob_storage,json=azureBlobStorage,oneof"` } func (*StorageBackend_Noop) isStorageBackend_Backend() {} func (*StorageBackend_Local) isStorageBackend_Backend() {} func (*StorageBackend_S3) isStorageBackend_Backend() {} func (*StorageBackend_Gcs) isStorageBackend_Backend() {} func (*StorageBackend_CloudDynamic) isStorageBackend_Backend() {} func (*StorageBackend_Hdfs) isStorageBackend_Backend() {} func (*StorageBackend_AzureBlobStorage) isStorageBackend_Backend() {} func (m *StorageBackend) GetBackend() isStorageBackend_Backend { if m != nil { return m.Backend } return nil } func (m *StorageBackend) GetNoop() *Noop { if x, ok := m.GetBackend().(*StorageBackend_Noop); ok { return x.Noop } return nil } func (m *StorageBackend) GetLocal() *Local { if x, ok := m.GetBackend().(*StorageBackend_Local); ok { return x.Local } return nil } func (m *StorageBackend) GetS3() *S3 { if x, ok := m.GetBackend().(*StorageBackend_S3); ok { return x.S3 } return nil } func (m *StorageBackend) GetGcs() *GCS { if x, ok := m.GetBackend().(*StorageBackend_Gcs); ok { return x.Gcs } return nil } func (m *StorageBackend) GetCloudDynamic() *CloudDynamic { if x, ok := m.GetBackend().(*StorageBackend_CloudDynamic); ok { return x.CloudDynamic } return nil } func (m *StorageBackend) GetHdfs() *HDFS { if x, ok := m.GetBackend().(*StorageBackend_Hdfs); ok { return x.Hdfs } return nil } func (m *StorageBackend) GetAzureBlobStorage() *AzureBlobStorage { if x, ok := m.GetBackend().(*StorageBackend_AzureBlobStorage); ok { return x.AzureBlobStorage } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*StorageBackend) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _StorageBackend_OneofMarshaler, _StorageBackend_OneofUnmarshaler, _StorageBackend_OneofSizer, []interface{}{ (*StorageBackend_Noop)(nil), (*StorageBackend_Local)(nil), (*StorageBackend_S3)(nil), (*StorageBackend_Gcs)(nil), (*StorageBackend_CloudDynamic)(nil), (*StorageBackend_Hdfs)(nil), (*StorageBackend_AzureBlobStorage)(nil), } } func _StorageBackend_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*StorageBackend) // backend switch x := m.Backend.(type) { case *StorageBackend_Noop: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Noop); err != nil { return err } case *StorageBackend_Local: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Local); err != nil { return err } case *StorageBackend_S3: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.S3); err != nil { return err } case *StorageBackend_Gcs: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Gcs); err != nil { return err } case *StorageBackend_CloudDynamic: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CloudDynamic); err != nil { return err } case *StorageBackend_Hdfs: _ = b.EncodeVarint(6<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Hdfs); err != nil { return err } case *StorageBackend_AzureBlobStorage: _ = b.EncodeVarint(7<<3 | proto.WireBytes) if err := b.EncodeMessage(x.AzureBlobStorage); err != nil { return err } case nil: default: return fmt.Errorf("StorageBackend.Backend has unexpected type %T", x) } return nil } func _StorageBackend_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*StorageBackend) switch tag { case 1: // backend.noop if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Noop) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Noop{msg} return true, err case 2: // backend.local if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Local) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Local{msg} return true, err case 3: // backend.s3 if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(S3) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_S3{msg} return true, err case 4: // backend.gcs if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(GCS) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Gcs{msg} return true, err case 5: // backend.cloud_dynamic if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(CloudDynamic) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_CloudDynamic{msg} return true, err case 6: // backend.hdfs if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(HDFS) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_Hdfs{msg} return true, err case 7: // backend.azure_blob_storage if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(AzureBlobStorage) err := b.DecodeMessage(msg) m.Backend = &StorageBackend_AzureBlobStorage{msg} return true, err default: return false, nil } } func _StorageBackend_OneofSizer(msg proto.Message) (n int) { m := msg.(*StorageBackend) // backend switch x := m.Backend.(type) { case *StorageBackend_Noop: s := proto.Size(x.Noop) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_Local: s := proto.Size(x.Local) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_S3: s := proto.Size(x.S3) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_Gcs: s := proto.Size(x.Gcs) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_CloudDynamic: s := proto.Size(x.CloudDynamic) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_Hdfs: s := proto.Size(x.Hdfs) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *StorageBackend_AzureBlobStorage: s := proto.Size(x.AzureBlobStorage) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } // Noop storage backend saves files into void. type Noop struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Noop) Reset() { *m = Noop{} } func (m *Noop) String() string { return proto.CompactTextString(m) } func (*Noop) ProtoMessage() {} func (*Noop) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{11} } func (m *Noop) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Noop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Noop.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Noop) XXX_Merge(src proto.Message) { xxx_messageInfo_Noop.Merge(dst, src) } func (m *Noop) XXX_Size() int { return m.Size() } func (m *Noop) XXX_DiscardUnknown() { xxx_messageInfo_Noop.DiscardUnknown(m) } var xxx_messageInfo_Noop proto.InternalMessageInfo // Local storage backend saves files into local disk type Local struct { Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Local) Reset() { *m = Local{} } func (m *Local) String() string { return proto.CompactTextString(m) } func (*Local) ProtoMessage() {} func (*Local) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{12} } func (m *Local) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Local) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Local.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Local) XXX_Merge(src proto.Message) { xxx_messageInfo_Local.Merge(dst, src) } func (m *Local) XXX_Size() int { return m.Size() } func (m *Local) XXX_DiscardUnknown() { xxx_messageInfo_Local.DiscardUnknown(m) } var xxx_messageInfo_Local proto.InternalMessageInfo func (m *Local) GetPath() string { if m != nil { return m.Path } return "" } // S3 storage backend saves files into S3 compatible storages // For non-aws providers, endpoint must be provided type S3 struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Region string `protobuf:"bytes,2,opt,name=region,proto3" json:"region,omitempty"` Bucket string `protobuf:"bytes,3,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,4,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,5,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` // server side encryption Sse string `protobuf:"bytes,6,opt,name=sse,proto3" json:"sse,omitempty"` Acl string `protobuf:"bytes,7,opt,name=acl,proto3" json:"acl,omitempty"` AccessKey string `protobuf:"bytes,8,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"` SecretAccessKey string `protobuf:"bytes,9,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"` ForcePathStyle bool `protobuf:"varint,10,opt,name=force_path_style,json=forcePathStyle,proto3" json:"force_path_style,omitempty"` SseKmsKeyId string `protobuf:"bytes,11,opt,name=sse_kms_key_id,json=sseKmsKeyId,proto3" json:"sse_kms_key_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *S3) Reset() { *m = S3{} } func (m *S3) String() string { return proto.CompactTextString(m) } func (*S3) ProtoMessage() {} func (*S3) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{13} } func (m *S3) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *S3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_S3.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *S3) XXX_Merge(src proto.Message) { xxx_messageInfo_S3.Merge(dst, src) } func (m *S3) XXX_Size() int { return m.Size() } func (m *S3) XXX_DiscardUnknown() { xxx_messageInfo_S3.DiscardUnknown(m) } var xxx_messageInfo_S3 proto.InternalMessageInfo func (m *S3) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *S3) GetRegion() string { if m != nil { return m.Region } return "" } func (m *S3) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *S3) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *S3) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } func (m *S3) GetSse() string { if m != nil { return m.Sse } return "" } func (m *S3) GetAcl() string { if m != nil { return m.Acl } return "" } func (m *S3) GetAccessKey() string { if m != nil { return m.AccessKey } return "" } func (m *S3) GetSecretAccessKey() string { if m != nil { return m.SecretAccessKey } return "" } func (m *S3) GetForcePathStyle() bool { if m != nil { return m.ForcePathStyle } return false } func (m *S3) GetSseKmsKeyId() string { if m != nil { return m.SseKmsKeyId } return "" } // GCS storage backend saves files into google cloud storage. type GCS struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Bucket string `protobuf:"bytes,2,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,4,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` // If not empty, applies a predefined set of access controls. // See https://cloud.google.com/storage/docs/access-control/lists#predefined-acl // for valid values. PredefinedAcl string `protobuf:"bytes,5,opt,name=predefined_acl,json=predefinedAcl,proto3" json:"predefined_acl,omitempty"` // Service Account Credentials JSON blob // You can get one from https://console.cloud.google.com/apis/credentials, and // copy the content, set it as string here. CredentialsBlob string `protobuf:"bytes,6,opt,name=credentials_blob,json=credentialsBlob,proto3" json:"credentials_blob,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GCS) Reset() { *m = GCS{} } func (m *GCS) String() string { return proto.CompactTextString(m) } func (*GCS) ProtoMessage() {} func (*GCS) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{14} } func (m *GCS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GCS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GCS.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GCS) XXX_Merge(src proto.Message) { xxx_messageInfo_GCS.Merge(dst, src) } func (m *GCS) XXX_Size() int { return m.Size() } func (m *GCS) XXX_DiscardUnknown() { xxx_messageInfo_GCS.DiscardUnknown(m) } var xxx_messageInfo_GCS proto.InternalMessageInfo func (m *GCS) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *GCS) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *GCS) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *GCS) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } func (m *GCS) GetPredefinedAcl() string { if m != nil { return m.PredefinedAcl } return "" } func (m *GCS) GetCredentialsBlob() string { if m != nil { return m.CredentialsBlob } return "" } // AzureBlobStorage storage backend saves files into azure blob storage. type AzureBlobStorage struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` // Alias: container Bucket string `protobuf:"bytes,2,opt,name=bucket,proto3" json:"bucket,omitempty"` // Notice: prefix starts without `/`, otherwise the first directory's name is empty. Prefix string `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"` // Alias: access_tier. // See https://docs.microsoft.com/en-us/azure/storage/blobs/access-tiers-overview StorageClass string `protobuf:"bytes,4,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` // if empty, try to read account_name from the node's environment variable $AZURE_STORAGE_ACCOUNT. AccountName string `protobuf:"bytes,5,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"` // Use shared key to access the azure blob // If the node's environment variables($AZURE_CLIENT_ID, $AZURE_TENANT_ID, $AZURE_CLIENT_SECRET) exist, // prefer to use token to access the azure blob. // // See https://docs.microsoft.com/en-us/azure/storage/common/identity-library-acquire-token?toc=/azure/storage/blobs/toc.json // // Otherwise, if empty, try to read shared key from the node's environment variable $AZURE_STORAGE_KEY. SharedKey string `protobuf:"bytes,6,opt,name=shared_key,json=sharedKey,proto3" json:"shared_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AzureBlobStorage) Reset() { *m = AzureBlobStorage{} } func (m *AzureBlobStorage) String() string { return proto.CompactTextString(m) } func (*AzureBlobStorage) ProtoMessage() {} func (*AzureBlobStorage) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{15} } func (m *AzureBlobStorage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AzureBlobStorage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AzureBlobStorage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AzureBlobStorage) XXX_Merge(src proto.Message) { xxx_messageInfo_AzureBlobStorage.Merge(dst, src) } func (m *AzureBlobStorage) XXX_Size() int { return m.Size() } func (m *AzureBlobStorage) XXX_DiscardUnknown() { xxx_messageInfo_AzureBlobStorage.DiscardUnknown(m) } var xxx_messageInfo_AzureBlobStorage proto.InternalMessageInfo func (m *AzureBlobStorage) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *AzureBlobStorage) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *AzureBlobStorage) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *AzureBlobStorage) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } func (m *AzureBlobStorage) GetAccountName() string { if m != nil { return m.AccountName } return "" } func (m *AzureBlobStorage) GetSharedKey() string { if m != nil { return m.SharedKey } return "" } type Bucket struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` Region string `protobuf:"bytes,3,opt,name=region,proto3" json:"region,omitempty"` Bucket string `protobuf:"bytes,4,opt,name=bucket,proto3" json:"bucket,omitempty"` Prefix string `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"` StorageClass string `protobuf:"bytes,6,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Bucket) Reset() { *m = Bucket{} } func (m *Bucket) String() string { return proto.CompactTextString(m) } func (*Bucket) ProtoMessage() {} func (*Bucket) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{16} } func (m *Bucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Bucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Bucket.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Bucket) XXX_Merge(src proto.Message) { xxx_messageInfo_Bucket.Merge(dst, src) } func (m *Bucket) XXX_Size() int { return m.Size() } func (m *Bucket) XXX_DiscardUnknown() { xxx_messageInfo_Bucket.DiscardUnknown(m) } var xxx_messageInfo_Bucket proto.InternalMessageInfo func (m *Bucket) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } func (m *Bucket) GetRegion() string { if m != nil { return m.Region } return "" } func (m *Bucket) GetBucket() string { if m != nil { return m.Bucket } return "" } func (m *Bucket) GetPrefix() string { if m != nil { return m.Prefix } return "" } func (m *Bucket) GetStorageClass() string { if m != nil { return m.StorageClass } return "" } // CloudDynamic allows testing new cloud providers and new fields without changing protobuf definitions type CloudDynamic struct { Bucket *Bucket `protobuf:"bytes,1,opt,name=bucket" json:"bucket,omitempty"` ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` Attrs map[string]string `protobuf:"bytes,3,rep,name=attrs" json:"attrs,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 *CloudDynamic) Reset() { *m = CloudDynamic{} } func (m *CloudDynamic) String() string { return proto.CompactTextString(m) } func (*CloudDynamic) ProtoMessage() {} func (*CloudDynamic) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{17} } func (m *CloudDynamic) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CloudDynamic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CloudDynamic.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CloudDynamic) XXX_Merge(src proto.Message) { xxx_messageInfo_CloudDynamic.Merge(dst, src) } func (m *CloudDynamic) XXX_Size() int { return m.Size() } func (m *CloudDynamic) XXX_DiscardUnknown() { xxx_messageInfo_CloudDynamic.DiscardUnknown(m) } var xxx_messageInfo_CloudDynamic proto.InternalMessageInfo func (m *CloudDynamic) GetBucket() *Bucket { if m != nil { return m.Bucket } return nil } func (m *CloudDynamic) GetProviderName() string { if m != nil { return m.ProviderName } return "" } func (m *CloudDynamic) GetAttrs() map[string]string { if m != nil { return m.Attrs } return nil } // HDFS storage backend saves file into HDFS compatible storages type HDFS struct { // a URL: hdfs:///some/path or hdfs://host:port/some/path Remote string `protobuf:"bytes,1,opt,name=remote,proto3" json:"remote,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *HDFS) Reset() { *m = HDFS{} } func (m *HDFS) String() string { return proto.CompactTextString(m) } func (*HDFS) ProtoMessage() {} func (*HDFS) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{18} } func (m *HDFS) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *HDFS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_HDFS.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *HDFS) XXX_Merge(src proto.Message) { xxx_messageInfo_HDFS.Merge(dst, src) } func (m *HDFS) XXX_Size() int { return m.Size() } func (m *HDFS) XXX_DiscardUnknown() { xxx_messageInfo_HDFS.DiscardUnknown(m) } var xxx_messageInfo_HDFS proto.InternalMessageInfo func (m *HDFS) GetRemote() string { if m != nil { return m.Remote } return "" } type BackupResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` Files []*File `protobuf:"bytes,4,rep,name=files" json:"files,omitempty"` // API version implies the encode of the key and value. ApiVersion kvrpcpb.APIVersion `protobuf:"varint,5,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BackupResponse) Reset() { *m = BackupResponse{} } func (m *BackupResponse) String() string { return proto.CompactTextString(m) } func (*BackupResponse) ProtoMessage() {} func (*BackupResponse) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{19} } func (m *BackupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BackupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BackupResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BackupResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BackupResponse.Merge(dst, src) } func (m *BackupResponse) XXX_Size() int { return m.Size() } func (m *BackupResponse) XXX_DiscardUnknown() { xxx_messageInfo_BackupResponse.DiscardUnknown(m) } var xxx_messageInfo_BackupResponse proto.InternalMessageInfo func (m *BackupResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *BackupResponse) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *BackupResponse) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *BackupResponse) GetFiles() []*File { if m != nil { return m.Files } return nil } func (m *BackupResponse) GetApiVersion() kvrpcpb.APIVersion { if m != nil { return m.ApiVersion } return kvrpcpb.APIVersion_V1 } type ExternalStorageRestoreRequest struct { StorageBackend *StorageBackend `protobuf:"bytes,1,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` ObjectName string `protobuf:"bytes,2,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` RestoreName string `protobuf:"bytes,3,opt,name=restore_name,json=restoreName,proto3" json:"restore_name,omitempty"` ContentLength uint64 `protobuf:"varint,4,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageRestoreRequest) Reset() { *m = ExternalStorageRestoreRequest{} } func (m *ExternalStorageRestoreRequest) String() string { return proto.CompactTextString(m) } func (*ExternalStorageRestoreRequest) ProtoMessage() {} func (*ExternalStorageRestoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{20} } func (m *ExternalStorageRestoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageRestoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageRestoreRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageRestoreRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageRestoreRequest.Merge(dst, src) } func (m *ExternalStorageRestoreRequest) XXX_Size() int { return m.Size() } func (m *ExternalStorageRestoreRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageRestoreRequest.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageRestoreRequest proto.InternalMessageInfo func (m *ExternalStorageRestoreRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *ExternalStorageRestoreRequest) GetObjectName() string { if m != nil { return m.ObjectName } return "" } func (m *ExternalStorageRestoreRequest) GetRestoreName() string { if m != nil { return m.RestoreName } return "" } func (m *ExternalStorageRestoreRequest) GetContentLength() uint64 { if m != nil { return m.ContentLength } return 0 } type ExternalStorageRestoreResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageRestoreResponse) Reset() { *m = ExternalStorageRestoreResponse{} } func (m *ExternalStorageRestoreResponse) String() string { return proto.CompactTextString(m) } func (*ExternalStorageRestoreResponse) ProtoMessage() {} func (*ExternalStorageRestoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{21} } func (m *ExternalStorageRestoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageRestoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageRestoreResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageRestoreResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageRestoreResponse.Merge(dst, src) } func (m *ExternalStorageRestoreResponse) XXX_Size() int { return m.Size() } func (m *ExternalStorageRestoreResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageRestoreResponse.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageRestoreResponse proto.InternalMessageInfo type ExternalStorageSaveRequest struct { StorageBackend *StorageBackend `protobuf:"bytes,1,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` ObjectName string `protobuf:"bytes,2,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` ContentLength uint64 `protobuf:"varint,3,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageSaveRequest) Reset() { *m = ExternalStorageSaveRequest{} } func (m *ExternalStorageSaveRequest) String() string { return proto.CompactTextString(m) } func (*ExternalStorageSaveRequest) ProtoMessage() {} func (*ExternalStorageSaveRequest) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{22} } func (m *ExternalStorageSaveRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageSaveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageSaveRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageSaveRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageSaveRequest.Merge(dst, src) } func (m *ExternalStorageSaveRequest) XXX_Size() int { return m.Size() } func (m *ExternalStorageSaveRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageSaveRequest.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageSaveRequest proto.InternalMessageInfo func (m *ExternalStorageSaveRequest) GetStorageBackend() *StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *ExternalStorageSaveRequest) GetObjectName() string { if m != nil { return m.ObjectName } return "" } func (m *ExternalStorageSaveRequest) GetContentLength() uint64 { if m != nil { return m.ContentLength } return 0 } type ExternalStorageSaveResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExternalStorageSaveResponse) Reset() { *m = ExternalStorageSaveResponse{} } func (m *ExternalStorageSaveResponse) String() string { return proto.CompactTextString(m) } func (*ExternalStorageSaveResponse) ProtoMessage() {} func (*ExternalStorageSaveResponse) Descriptor() ([]byte, []int) { return fileDescriptor_brpb_9a2c249b8987200a, []int{23} } func (m *ExternalStorageSaveResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExternalStorageSaveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExternalStorageSaveResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExternalStorageSaveResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExternalStorageSaveResponse.Merge(dst, src) } func (m *ExternalStorageSaveResponse) XXX_Size() int { return m.Size() } func (m *ExternalStorageSaveResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExternalStorageSaveResponse.DiscardUnknown(m) } var xxx_messageInfo_ExternalStorageSaveResponse proto.InternalMessageInfo func init() { proto.RegisterType((*BackupMeta)(nil), "backup.BackupMeta") proto.RegisterType((*File)(nil), "backup.File") proto.RegisterType((*MetaFile)(nil), "backup.MetaFile") proto.RegisterType((*PlacementPolicy)(nil), "backup.PlacementPolicy") proto.RegisterType((*Schema)(nil), "backup.Schema") proto.RegisterType((*RawRange)(nil), "backup.RawRange") proto.RegisterType((*ClusterIDError)(nil), "backup.ClusterIDError") proto.RegisterType((*Error)(nil), "backup.Error") proto.RegisterType((*CipherInfo)(nil), "backup.CipherInfo") proto.RegisterType((*BackupRequest)(nil), "backup.BackupRequest") proto.RegisterType((*StorageBackend)(nil), "backup.StorageBackend") proto.RegisterType((*Noop)(nil), "backup.Noop") proto.RegisterType((*Local)(nil), "backup.Local") proto.RegisterType((*S3)(nil), "backup.S3") proto.RegisterType((*GCS)(nil), "backup.GCS") proto.RegisterType((*AzureBlobStorage)(nil), "backup.AzureBlobStorage") proto.RegisterType((*Bucket)(nil), "backup.Bucket") proto.RegisterType((*CloudDynamic)(nil), "backup.CloudDynamic") proto.RegisterMapType((map[string]string)(nil), "backup.CloudDynamic.AttrsEntry") proto.RegisterType((*HDFS)(nil), "backup.HDFS") proto.RegisterType((*BackupResponse)(nil), "backup.BackupResponse") proto.RegisterType((*ExternalStorageRestoreRequest)(nil), "backup.ExternalStorageRestoreRequest") proto.RegisterType((*ExternalStorageRestoreResponse)(nil), "backup.ExternalStorageRestoreResponse") proto.RegisterType((*ExternalStorageSaveRequest)(nil), "backup.ExternalStorageSaveRequest") proto.RegisterType((*ExternalStorageSaveResponse)(nil), "backup.ExternalStorageSaveResponse") proto.RegisterEnum("backup.CompressionType", CompressionType_name, CompressionType_value) } // 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 // Client API for Backup service type BackupClient interface { Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) } type backupClient struct { cc *grpc.ClientConn } func NewBackupClient(cc *grpc.ClientConn) BackupClient { return &backupClient{cc} } func (c *backupClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) { stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[0], "/backup.Backup/backup", opts...) if err != nil { return nil, err } x := &backupBackupClient{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 Backup_BackupClient interface { Recv() (*BackupResponse, error) grpc.ClientStream } type backupBackupClient struct { grpc.ClientStream } func (x *backupBackupClient) Recv() (*BackupResponse, error) { m := new(BackupResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for Backup service type BackupServer interface { Backup(*BackupRequest, Backup_BackupServer) error } func RegisterBackupServer(s *grpc.Server, srv BackupServer) { s.RegisterService(&_Backup_serviceDesc, srv) } func _Backup_Backup_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(BackupRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BackupServer).Backup(m, &backupBackupServer{stream}) } type Backup_BackupServer interface { Send(*BackupResponse) error grpc.ServerStream } type backupBackupServer struct { grpc.ServerStream } func (x *backupBackupServer) Send(m *BackupResponse) error { return x.ServerStream.SendMsg(m) } var _Backup_serviceDesc = grpc.ServiceDesc{ ServiceName: "backup.Backup", HandlerType: (*BackupServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "backup", Handler: _Backup_Backup_Handler, ServerStreams: true, }, }, Metadata: "brpb.proto", } // Client API for ExternalStorage service type ExternalStorageClient interface { // Restore to a file Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) // Save a file to storage Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) } type externalStorageClient struct { cc *grpc.ClientConn } func NewExternalStorageClient(cc *grpc.ClientConn) ExternalStorageClient { return &externalStorageClient{cc} } func (c *externalStorageClient) Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) { out := new(ExternalStorageRestoreResponse) err := c.cc.Invoke(ctx, "/backup.ExternalStorage/restore", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *externalStorageClient) Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) { out := new(ExternalStorageSaveResponse) err := c.cc.Invoke(ctx, "/backup.ExternalStorage/save", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for ExternalStorage service type ExternalStorageServer interface { // Restore to a file Restore(context.Context, *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) // Save a file to storage Save(context.Context, *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) } func RegisterExternalStorageServer(s *grpc.Server, srv ExternalStorageServer) { s.RegisterService(&_ExternalStorage_serviceDesc, srv) } func _ExternalStorage_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExternalStorageRestoreRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ExternalStorageServer).Restore(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/backup.ExternalStorage/Restore", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ExternalStorageServer).Restore(ctx, req.(*ExternalStorageRestoreRequest)) } return interceptor(ctx, in, info, handler) } func _ExternalStorage_Save_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExternalStorageSaveRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ExternalStorageServer).Save(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/backup.ExternalStorage/Save", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ExternalStorageServer).Save(ctx, req.(*ExternalStorageSaveRequest)) } return interceptor(ctx, in, info, handler) } var _ExternalStorage_serviceDesc = grpc.ServiceDesc{ ServiceName: "backup.ExternalStorage", HandlerType: (*ExternalStorageServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "restore", Handler: _ExternalStorage_Restore_Handler, }, { MethodName: "save", Handler: _ExternalStorage_Save_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "brpb.proto", } func (m *BackupMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ClusterId)) } if len(m.ClusterVersion) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.ClusterVersion))) i += copy(dAtA[i:], m.ClusterVersion) } if len(m.Files) > 0 { for _, msg := range m.Files { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.StartVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) } if len(m.Schemas) > 0 { for _, msg := range m.Schemas { dAtA[i] = 0x3a i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.IsRawKv { dAtA[i] = 0x40 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.RawRanges) > 0 { for _, msg := range m.RawRanges { dAtA[i] = 0x4a i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Ddls) > 0 { dAtA[i] = 0x52 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Ddls))) i += copy(dAtA[i:], m.Ddls) } if len(m.BrVersion) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.BrVersion))) i += copy(dAtA[i:], m.BrVersion) } if m.Version != 0 { dAtA[i] = 0x60 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Version)) } if m.FileIndex != nil { dAtA[i] = 0x6a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.FileIndex.Size())) n1, err := m.FileIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.SchemaIndex != nil { dAtA[i] = 0x72 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.SchemaIndex.Size())) n2, err := m.SchemaIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.RawRangeIndex != nil { dAtA[i] = 0x7a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.RawRangeIndex.Size())) n3, err := m.RawRangeIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.DdlIndexes != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.DdlIndexes.Size())) n4, err := m.DdlIndexes.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if len(m.BackupResult) > 0 { dAtA[i] = 0x8a i++ dAtA[i] = 0x1 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.BackupResult))) i += copy(dAtA[i:], m.BackupResult) } if m.ApiVersion != 0 { dAtA[i] = 0x90 i++ dAtA[i] = 0x1 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ApiVersion)) } if len(m.Policies) > 0 { for _, msg := range m.Policies { dAtA[i] = 0x9a i++ dAtA[i] = 0x1 i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *File) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *File) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Sha256) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Sha256))) i += copy(dAtA[i:], m.Sha256) } if len(m.StartKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.StartVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) } if m.Crc64Xor != 0 { dAtA[i] = 0x38 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { dAtA[i] = 0x40 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x48 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) } if len(m.Cf) > 0 { dAtA[i] = 0x52 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Size_ != 0 { dAtA[i] = 0x58 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Size_)) } if len(m.CipherIv) > 0 { dAtA[i] = 0x62 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherIv))) i += copy(dAtA[i:], m.CipherIv) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MetaFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MetaFile) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.MetaFiles) > 0 { for _, msg := range m.MetaFiles { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.DataFiles) > 0 { for _, msg := range m.DataFiles { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Schemas) > 0 { for _, msg := range m.Schemas { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.RawRanges) > 0 { for _, msg := range m.RawRanges { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Ddls) > 0 { for _, b := range m.Ddls { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PlacementPolicy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PlacementPolicy) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Info) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Info))) i += copy(dAtA[i:], m.Info) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Schema) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Schema) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Db) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Db))) i += copy(dAtA[i:], m.Db) } if len(m.Table) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Table))) i += copy(dAtA[i:], m.Table) } if m.Crc64Xor != 0 { dAtA[i] = 0x18 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) } if m.TiflashReplicas != 0 { dAtA[i] = 0x30 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.TiflashReplicas)) } if len(m.Stats) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Stats))) i += copy(dAtA[i:], m.Stats) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawRange) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.StartKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ClusterIDError) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ClusterIDError) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Current != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Current)) } if m.Request != 0 { dAtA[i] = 0x10 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Request)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Msg) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Msg))) i += copy(dAtA[i:], m.Msg) } if m.Detail != nil { nn5, err := m.Detail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn5 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error_ClusterIdError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ClusterIdError != nil { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ClusterIdError.Size())) n6, err := m.ClusterIdError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } return i, nil } func (m *Error_KvError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.KvError != nil { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.KvError.Size())) n7, err := m.KvError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } return i, nil } func (m *Error_RegionError) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RegionError != nil { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.RegionError.Size())) n8, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } return i, nil } func (m *CipherInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CipherInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CipherType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.CipherType)) } if len(m.CipherKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherKey))) i += copy(dAtA[i:], m.CipherKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BackupRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ClusterId)) } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.StartVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) } if m.EndVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) } if m.RateLimit != 0 { dAtA[i] = 0x38 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.RateLimit)) } if m.Concurrency != 0 { dAtA[i] = 0x40 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Concurrency)) } if m.StorageBackend != nil { dAtA[i] = 0x4a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StorageBackend.Size())) n9, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.IsRawKv { dAtA[i] = 0x50 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Cf) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.CompressionType != 0 { dAtA[i] = 0x60 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.CompressionType)) } if m.CompressionLevel != 0 { dAtA[i] = 0x68 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.CompressionLevel)) } if m.CipherInfo != nil { dAtA[i] = 0x72 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.CipherInfo.Size())) n10, err := m.CipherInfo.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StorageBackend) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StorageBackend) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Backend != nil { nn11, err := m.Backend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn11 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StorageBackend_Noop) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Noop != nil { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Noop.Size())) n12, err := m.Noop.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } return i, nil } func (m *StorageBackend_Local) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Local != nil { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Local.Size())) n13, err := m.Local.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } return i, nil } func (m *StorageBackend_S3) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.S3 != nil { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.S3.Size())) n14, err := m.S3.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } return i, nil } func (m *StorageBackend_Gcs) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Gcs != nil { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Gcs.Size())) n15, err := m.Gcs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } return i, nil } func (m *StorageBackend_CloudDynamic) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CloudDynamic != nil { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.CloudDynamic.Size())) n16, err := m.CloudDynamic.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } return i, nil } func (m *StorageBackend_Hdfs) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Hdfs != nil { dAtA[i] = 0x32 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Hdfs.Size())) n17, err := m.Hdfs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } return i, nil } func (m *StorageBackend_AzureBlobStorage) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.AzureBlobStorage != nil { dAtA[i] = 0x3a i++ i = encodeVarintBrpb(dAtA, i, uint64(m.AzureBlobStorage.Size())) n18, err := m.AzureBlobStorage.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } return i, nil } func (m *Noop) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Noop) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Local) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Local) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Path) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Path))) i += copy(dAtA[i:], m.Path) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *S3) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *S3) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Region) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Region))) i += copy(dAtA[i:], m.Region) } if len(m.Bucket) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if len(m.Sse) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Sse))) i += copy(dAtA[i:], m.Sse) } if len(m.Acl) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Acl))) i += copy(dAtA[i:], m.Acl) } if len(m.AccessKey) > 0 { dAtA[i] = 0x42 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.AccessKey))) i += copy(dAtA[i:], m.AccessKey) } if len(m.SecretAccessKey) > 0 { dAtA[i] = 0x4a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.SecretAccessKey))) i += copy(dAtA[i:], m.SecretAccessKey) } if m.ForcePathStyle { dAtA[i] = 0x50 i++ if m.ForcePathStyle { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.SseKmsKeyId) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.SseKmsKeyId))) i += copy(dAtA[i:], m.SseKmsKeyId) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GCS) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GCS) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Bucket) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if len(m.PredefinedAcl) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.PredefinedAcl))) i += copy(dAtA[i:], m.PredefinedAcl) } if len(m.CredentialsBlob) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.CredentialsBlob))) i += copy(dAtA[i:], m.CredentialsBlob) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AzureBlobStorage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AzureBlobStorage) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Bucket) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if len(m.AccountName) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.AccountName))) i += copy(dAtA[i:], m.AccountName) } if len(m.SharedKey) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.SharedKey))) i += copy(dAtA[i:], m.SharedKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Bucket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Bucket) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Endpoint) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if len(m.Region) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Region))) i += copy(dAtA[i:], m.Region) } if len(m.Bucket) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Bucket))) i += copy(dAtA[i:], m.Bucket) } if len(m.Prefix) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Prefix))) i += copy(dAtA[i:], m.Prefix) } if len(m.StorageClass) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StorageClass))) i += copy(dAtA[i:], m.StorageClass) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CloudDynamic) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CloudDynamic) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Bucket != nil { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Bucket.Size())) n19, err := m.Bucket.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if len(m.ProviderName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.ProviderName))) i += copy(dAtA[i:], m.ProviderName) } if len(m.Attrs) > 0 { for k, _ := range m.Attrs { dAtA[i] = 0x1a i++ v := m.Attrs[k] mapSize := 1 + len(k) + sovBrpb(uint64(len(k))) + 1 + len(v) + sovBrpb(uint64(len(v))) i = encodeVarintBrpb(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(k))) i += copy(dAtA[i:], k) dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(v))) i += copy(dAtA[i:], v) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *HDFS) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *HDFS) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Remote) > 0 { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.Remote))) i += copy(dAtA[i:], m.Remote) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BackupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BackupResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(m.Error.Size())) n20, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if len(m.Files) > 0 { for _, msg := range m.Files { dAtA[i] = 0x22 i++ i = encodeVarintBrpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.ApiVersion != 0 { dAtA[i] = 0x28 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageRestoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageRestoreRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StorageBackend != nil { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StorageBackend.Size())) n21, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } if len(m.ObjectName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.ObjectName))) i += copy(dAtA[i:], m.ObjectName) } if len(m.RestoreName) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.RestoreName))) i += copy(dAtA[i:], m.RestoreName) } if m.ContentLength != 0 { dAtA[i] = 0x20 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageRestoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageRestoreResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageSaveRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageSaveRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StorageBackend != nil { dAtA[i] = 0xa i++ i = encodeVarintBrpb(dAtA, i, uint64(m.StorageBackend.Size())) n22, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } if len(m.ObjectName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintBrpb(dAtA, i, uint64(len(m.ObjectName))) i += copy(dAtA[i:], m.ObjectName) } if m.ContentLength != 0 { dAtA[i] = 0x18 i++ i = encodeVarintBrpb(dAtA, i, uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExternalStorageSaveResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExternalStorageSaveResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintBrpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *BackupMeta) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovBrpb(uint64(m.ClusterId)) } l = len(m.ClusterVersion) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if len(m.Files) > 0 { for _, e := range m.Files { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if m.StartVersion != 0 { n += 1 + sovBrpb(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBrpb(uint64(m.EndVersion)) } if len(m.Schemas) > 0 { for _, e := range m.Schemas { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if m.IsRawKv { n += 2 } if len(m.RawRanges) > 0 { for _, e := range m.RawRanges { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } l = len(m.Ddls) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.BrVersion) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.Version != 0 { n += 1 + sovBrpb(uint64(m.Version)) } if m.FileIndex != nil { l = m.FileIndex.Size() n += 1 + l + sovBrpb(uint64(l)) } if m.SchemaIndex != nil { l = m.SchemaIndex.Size() n += 1 + l + sovBrpb(uint64(l)) } if m.RawRangeIndex != nil { l = m.RawRangeIndex.Size() n += 1 + l + sovBrpb(uint64(l)) } if m.DdlIndexes != nil { l = m.DdlIndexes.Size() n += 2 + l + sovBrpb(uint64(l)) } l = len(m.BackupResult) if l > 0 { n += 2 + l + sovBrpb(uint64(l)) } if m.ApiVersion != 0 { n += 2 + sovBrpb(uint64(m.ApiVersion)) } if len(m.Policies) > 0 { for _, e := range m.Policies { l = e.Size() n += 2 + l + sovBrpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *File) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Sha256) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovBrpb(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBrpb(uint64(m.EndVersion)) } if m.Crc64Xor != 0 { n += 1 + sovBrpb(uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { n += 1 + sovBrpb(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovBrpb(uint64(m.TotalBytes)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.Size_ != 0 { n += 1 + sovBrpb(uint64(m.Size_)) } l = len(m.CipherIv) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MetaFile) Size() (n int) { var l int _ = l if len(m.MetaFiles) > 0 { for _, e := range m.MetaFiles { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if len(m.DataFiles) > 0 { for _, e := range m.DataFiles { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if len(m.Schemas) > 0 { for _, e := range m.Schemas { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if len(m.RawRanges) > 0 { for _, e := range m.RawRanges { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if len(m.Ddls) > 0 { for _, b := range m.Ddls { l = len(b) n += 1 + l + sovBrpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PlacementPolicy) Size() (n int) { var l int _ = l l = len(m.Info) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Schema) Size() (n int) { var l int _ = l l = len(m.Db) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Table) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.Crc64Xor != 0 { n += 1 + sovBrpb(uint64(m.Crc64Xor)) } if m.TotalKvs != 0 { n += 1 + sovBrpb(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovBrpb(uint64(m.TotalBytes)) } if m.TiflashReplicas != 0 { n += 1 + sovBrpb(uint64(m.TiflashReplicas)) } l = len(m.Stats) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawRange) Size() (n int) { var l int _ = l l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ClusterIDError) Size() (n int) { var l int _ = l if m.Current != 0 { n += 1 + sovBrpb(uint64(m.Current)) } if m.Request != 0 { n += 1 + sovBrpb(uint64(m.Request)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l l = len(m.Msg) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.Detail != nil { n += m.Detail.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error_ClusterIdError) Size() (n int) { var l int _ = l if m.ClusterIdError != nil { l = m.ClusterIdError.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *Error_KvError) Size() (n int) { var l int _ = l if m.KvError != nil { l = m.KvError.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *Error_RegionError) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *CipherInfo) Size() (n int) { var l int _ = l if m.CipherType != 0 { n += 1 + sovBrpb(uint64(m.CipherType)) } l = len(m.CipherKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BackupRequest) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovBrpb(uint64(m.ClusterId)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovBrpb(uint64(m.StartVersion)) } if m.EndVersion != 0 { n += 1 + sovBrpb(uint64(m.EndVersion)) } if m.RateLimit != 0 { n += 1 + sovBrpb(uint64(m.RateLimit)) } if m.Concurrency != 0 { n += 1 + sovBrpb(uint64(m.Concurrency)) } if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBrpb(uint64(l)) } if m.IsRawKv { n += 2 } l = len(m.Cf) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.CompressionType != 0 { n += 1 + sovBrpb(uint64(m.CompressionType)) } if m.CompressionLevel != 0 { n += 1 + sovBrpb(uint64(m.CompressionLevel)) } if m.CipherInfo != nil { l = m.CipherInfo.Size() n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StorageBackend) Size() (n int) { var l int _ = l if m.Backend != nil { n += m.Backend.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StorageBackend_Noop) Size() (n int) { var l int _ = l if m.Noop != nil { l = m.Noop.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_Local) Size() (n int) { var l int _ = l if m.Local != nil { l = m.Local.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_S3) Size() (n int) { var l int _ = l if m.S3 != nil { l = m.S3.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_Gcs) Size() (n int) { var l int _ = l if m.Gcs != nil { l = m.Gcs.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_CloudDynamic) Size() (n int) { var l int _ = l if m.CloudDynamic != nil { l = m.CloudDynamic.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_Hdfs) Size() (n int) { var l int _ = l if m.Hdfs != nil { l = m.Hdfs.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *StorageBackend_AzureBlobStorage) Size() (n int) { var l int _ = l if m.AzureBlobStorage != nil { l = m.AzureBlobStorage.Size() n += 1 + l + sovBrpb(uint64(l)) } return n } func (m *Noop) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Local) Size() (n int) { var l int _ = l l = len(m.Path) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *S3) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Region) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Sse) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Acl) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.AccessKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.SecretAccessKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.ForcePathStyle { n += 2 } l = len(m.SseKmsKeyId) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GCS) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.PredefinedAcl) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.CredentialsBlob) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AzureBlobStorage) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.AccountName) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.SharedKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Bucket) Size() (n int) { var l int _ = l l = len(m.Endpoint) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Region) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Bucket) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.Prefix) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StorageClass) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CloudDynamic) Size() (n int) { var l int _ = l if m.Bucket != nil { l = m.Bucket.Size() n += 1 + l + sovBrpb(uint64(l)) } l = len(m.ProviderName) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if len(m.Attrs) > 0 { for k, v := range m.Attrs { _ = k _ = v mapEntrySize := 1 + len(k) + sovBrpb(uint64(len(k))) + 1 + len(v) + sovBrpb(uint64(len(v))) n += mapEntrySize + 1 + sovBrpb(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *HDFS) Size() (n int) { var l int _ = l l = len(m.Remote) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BackupResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovBrpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if len(m.Files) > 0 { for _, e := range m.Files { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } if m.ApiVersion != 0 { n += 1 + sovBrpb(uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageRestoreRequest) Size() (n int) { var l int _ = l if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBrpb(uint64(l)) } l = len(m.ObjectName) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } l = len(m.RestoreName) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.ContentLength != 0 { n += 1 + sovBrpb(uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageRestoreResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageSaveRequest) Size() (n int) { var l int _ = l if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovBrpb(uint64(l)) } l = len(m.ObjectName) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } if m.ContentLength != 0 { n += 1 + sovBrpb(uint64(m.ContentLength)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExternalStorageSaveResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovBrpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozBrpb(x uint64) (n int) { return sovBrpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *BackupMeta) 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 ErrIntOverflowBrpb } 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: BackupMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ClusterVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Files = append(m.Files, &File{}) if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Schemas = append(m.Schemas, &Schema{}) if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RawRanges = append(m.RawRanges, &RawRange{}) if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Ddls = append(m.Ddls[:0], dAtA[iNdEx:postIndex]...) if m.Ddls == nil { m.Ddls = []byte{} } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BrVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.BrVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FileIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.FileIndex == nil { m.FileIndex = &MetaFile{} } if err := m.FileIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SchemaIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.SchemaIndex == nil { m.SchemaIndex = &MetaFile{} } if err := m.SchemaIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawRangeIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RawRangeIndex == nil { m.RawRangeIndex = &MetaFile{} } if err := m.RawRangeIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DdlIndexes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DdlIndexes == nil { m.DdlIndexes = &MetaFile{} } if err := m.DdlIndexes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 17: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BackupResult", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.BackupResult = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 18: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (kvrpcpb.APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Policies = append(m.Policies, &PlacementPolicy{}) if err := m.Policies[len(m.Policies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *File) 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 ErrIntOverflowBrpb } 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: File: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: File: 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 ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen 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 Sha256", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) if m.Sha256 == nil { m.Sha256 = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc64Xor |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 11: 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 ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) if m.CipherIv == nil { m.CipherIv = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *MetaFile) 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 ErrIntOverflowBrpb } 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: MetaFile: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MetaFile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MetaFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.MetaFiles = append(m.MetaFiles, &File{}) if err := m.MetaFiles[len(m.MetaFiles)-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 DataFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.DataFiles = append(m.DataFiles, &File{}) if err := m.DataFiles[len(m.DataFiles)-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 Schemas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Schemas = append(m.Schemas, &Schema{}) if err := m.Schemas[len(m.Schemas)-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 RawRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RawRanges = append(m.RawRanges, &RawRange{}) if err := m.RawRanges[len(m.RawRanges)-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 Ddls", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Ddls = append(m.Ddls, make([]byte, postIndex-iNdEx)) copy(m.Ddls[len(m.Ddls)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *PlacementPolicy) 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 ErrIntOverflowBrpb } 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: PlacementPolicy: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PlacementPolicy: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Info = append(m.Info[:0], dAtA[iNdEx:postIndex]...) if m.Info == nil { m.Info = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *Schema) 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 ErrIntOverflowBrpb } 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: Schema: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Schema: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Db = append(m.Db[:0], dAtA[iNdEx:postIndex]...) if m.Db == nil { m.Db = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Table = append(m.Table[:0], dAtA[iNdEx:postIndex]...) if m.Table == nil { m.Table = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc64Xor |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TiflashReplicas", wireType) } m.TiflashReplicas = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TiflashReplicas |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Stats = append(m.Stats[:0], dAtA[iNdEx:postIndex]...) if m.Stats == nil { m.Stats = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *RawRange) 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 ErrIntOverflowBrpb } 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: RawRange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *ClusterIDError) 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 ErrIntOverflowBrpb } 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: ClusterIDError: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ClusterIDError: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) } m.Current = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Current |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } m.Request = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Request |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *Error) 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 ErrIntOverflowBrpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Msg = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &ClusterIDError{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_ClusterIdError{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KvError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.KeyError{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_KvError{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &errorpb.Error{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Detail = &Error_RegionError{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *CipherInfo) 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 ErrIntOverflowBrpb } 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: CipherInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CipherInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CipherType", wireType) } m.CipherType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CipherType |= (encryptionpb.EncryptionMethod(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CipherKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.CipherKey = append(m.CipherKey[:0], dAtA[iNdEx:postIndex]...) if m.CipherKey == nil { m.CipherKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *BackupRequest) 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 ErrIntOverflowBrpb } 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: BackupRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RateLimit", wireType) } m.RateLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RateLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType) } m.Concurrency = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Concurrency |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) } m.CompressionType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompressionType |= (CompressionType(b) & 0x7F) << shift if b < 0x80 { break } } case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompressionLevel", wireType) } m.CompressionLevel = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompressionLevel |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CipherInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CipherInfo == nil { m.CipherInfo = &CipherInfo{} } if err := m.CipherInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *StorageBackend) 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 ErrIntOverflowBrpb } 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: StorageBackend: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StorageBackend: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Noop", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Noop{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Noop{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Local{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Local{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S3", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &S3{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_S3{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Gcs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &GCS{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Gcs{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CloudDynamic", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &CloudDynamic{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_CloudDynamic{v} iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Hdfs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &HDFS{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_Hdfs{v} iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AzureBlobStorage", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &AzureBlobStorage{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &StorageBackend_AzureBlobStorage{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *Noop) 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 ErrIntOverflowBrpb } 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: Noop: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Noop: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *Local) 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 ErrIntOverflowBrpb } 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: Local: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Local: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *S3) 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 ErrIntOverflowBrpb } 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: S3: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: S3: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sse", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Sse = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Acl", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Acl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.AccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SecretAccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForcePathStyle", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForcePathStyle = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SseKmsKeyId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SseKmsKeyId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *GCS) 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 ErrIntOverflowBrpb } 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: GCS: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GCS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PredefinedAcl", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PredefinedAcl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CredentialsBlob", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.CredentialsBlob = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *AzureBlobStorage) 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 ErrIntOverflowBrpb } 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: AzureBlobStorage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AzureBlobStorage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AccountName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.AccountName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SharedKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SharedKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *Bucket) 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 ErrIntOverflowBrpb } 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: Bucket: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Bucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *CloudDynamic) 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 ErrIntOverflowBrpb } 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: CloudDynamic: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CloudDynamic: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Bucket == nil { m.Bucket = &Bucket{} } if err := m.Bucket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ProviderName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Attrs == nil { m.Attrs = 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 ErrIntOverflowBrpb } 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 ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postStringIndexmapkey := iNdEx + intStringLenmapkey 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 ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Attrs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *HDFS) 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 ErrIntOverflowBrpb } 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: HDFS: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: HDFS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Remote = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *BackupResponse) 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 ErrIntOverflowBrpb } 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: BackupResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Files = append(m.Files, &File{}) if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (kvrpcpb.APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *ExternalStorageRestoreRequest) 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 ErrIntOverflowBrpb } 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: ExternalStorageRestoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageRestoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RestoreName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.RestoreName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContentLength |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *ExternalStorageRestoreResponse) 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 ErrIntOverflowBrpb } 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: ExternalStorageRestoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageRestoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *ExternalStorageSaveRequest) 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 ErrIntOverflowBrpb } 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: ExternalStorageSaveRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageSaveRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthBrpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } 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 ErrInvalidLengthBrpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContentLength |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 *ExternalStorageSaveResponse) 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 ErrIntOverflowBrpb } 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: ExternalStorageSaveResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExternalStorageSaveResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthBrpb } 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 skipBrpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBrpb } 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, ErrIntOverflowBrpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBrpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthBrpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowBrpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipBrpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthBrpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowBrpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("brpb.proto", fileDescriptor_brpb_9a2c249b8987200a) } var fileDescriptor_brpb_9a2c249b8987200a = []byte{ // 2017 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0x1b, 0xc7, 0x15, 0xe6, 0x92, 0xcb, 0x9f, 0x3d, 0xfc, 0xf5, 0xc4, 0x75, 0x08, 0xba, 0x96, 0x99, 0x35, 0xec, 0xaa, 0x09, 0xc0, 0xb4, 0x92, 0x13, 0x18, 0x0d, 0x8a, 0x40, 0x94, 0x95, 0x48, 0x91, 0xa2, 0xaa, 0xa3, 0xb4, 0x45, 0x7d, 0xb3, 0x58, 0xee, 0x0e, 0xc5, 0x2d, 0x97, 0xbb, 0xdb, 0x9d, 0x21, 0x6d, 0xe6, 0x11, 0x7a, 0xd7, 0xbb, 0xbe, 0x40, 0x81, 0x3e, 0x46, 0x6f, 0x0a, 0x24, 0x48, 0x2f, 0x02, 0xf4, 0xa6, 0x97, 0x85, 0xfb, 0x04, 0x7d, 0x83, 0xe2, 0xcc, 0xcc, 0xae, 0x48, 0x59, 0x94, 0xdd, 0x22, 0xc8, 0x95, 0x66, 0xbe, 0x73, 0x66, 0x66, 0xe7, 0x3b, 0xdf, 0x39, 0x67, 0x28, 0x80, 0x51, 0x9a, 0x8c, 0x06, 0x49, 0x1a, 0x8b, 0x98, 0x54, 0x46, 0xae, 0x37, 0x9d, 0x27, 0xbd, 0xe6, 0x74, 0x91, 0x26, 0x5e, 0x06, 0xf7, 0x9a, 0x2c, 0x4d, 0xe3, 0xdc, 0xab, 0x47, 0x58, 0xe4, 0xa5, 0xcb, 0x44, 0x04, 0x71, 0x94, 0x63, 0xb7, 0x2f, 0xe2, 0x8b, 0x58, 0x0e, 0xdf, 0xc7, 0x91, 0x46, 0xdb, 0xe9, 0x9c, 0x0b, 0x39, 0x54, 0x80, 0xfd, 0x9f, 0x32, 0xc0, 0x50, 0x9e, 0xf1, 0x39, 0x13, 0x2e, 0xb9, 0x07, 0xe0, 0x85, 0x73, 0x2e, 0x58, 0xea, 0x04, 0x7e, 0xd7, 0xe8, 0x1b, 0xdb, 0x26, 0xb5, 0x34, 0x72, 0xe4, 0x93, 0x1f, 0x41, 0x3b, 0x33, 0x2f, 0x58, 0xca, 0x83, 0x38, 0xea, 0x16, 0xfb, 0xc6, 0xb6, 0x45, 0x5b, 0x1a, 0xfe, 0xb5, 0x42, 0x89, 0x0d, 0xe5, 0x71, 0x10, 0x32, 0xde, 0x35, 0xfb, 0xa5, 0xed, 0xfa, 0x4e, 0x63, 0xa0, 0xee, 0x31, 0xf8, 0x24, 0x08, 0x19, 0x55, 0x26, 0xf2, 0x00, 0x9a, 0x5c, 0xb8, 0xa9, 0xc8, 0xb7, 0x2a, 0xcb, 0xe3, 0x1a, 0x12, 0xcc, 0x36, 0xba, 0x0f, 0x75, 0x16, 0xf9, 0xb9, 0x4b, 0x45, 0xba, 0x00, 0x8b, 0xfc, 0xcc, 0x61, 0x1b, 0xaa, 0xdc, 0x9b, 0xb0, 0x99, 0xcb, 0xbb, 0x55, 0x79, 0x56, 0x2b, 0x3b, 0xeb, 0x5c, 0xc2, 0x34, 0x33, 0x93, 0x1e, 0x58, 0x01, 0x77, 0x52, 0xf7, 0xb9, 0x33, 0x5d, 0x74, 0x6b, 0x7d, 0x63, 0xbb, 0x46, 0xab, 0x01, 0xa7, 0xee, 0xf3, 0xe3, 0x05, 0x79, 0x1f, 0x00, 0x0d, 0xa9, 0x1b, 0x5d, 0x30, 0xde, 0xb5, 0xe4, 0x46, 0x9d, 0x6c, 0x23, 0xea, 0x3e, 0xa7, 0x68, 0xa0, 0x56, 0xaa, 0x47, 0x9c, 0x10, 0x30, 0x7d, 0x3f, 0xe4, 0x5d, 0xe8, 0x1b, 0xdb, 0x0d, 0x2a, 0xc7, 0x48, 0xde, 0xe8, 0x92, 0x98, 0xba, 0x24, 0xc6, 0x1a, 0xe5, 0x9c, 0x74, 0xa1, 0x9a, 0xd9, 0x1a, 0x7d, 0x63, 0xbb, 0x4c, 0xb3, 0x29, 0x9e, 0x8e, 0x94, 0x38, 0x41, 0xe4, 0xb3, 0x17, 0xdd, 0x66, 0xdf, 0x58, 0x3d, 0x1d, 0xe3, 0x22, 0x69, 0xb3, 0xd0, 0xe7, 0x08, 0x5d, 0xc8, 0x2e, 0x34, 0xd4, 0xad, 0xf4, 0x92, 0xd6, 0x86, 0x25, 0x75, 0xe5, 0xa5, 0x16, 0x3d, 0x81, 0x76, 0x7e, 0x47, 0xbd, 0xae, 0xbd, 0x61, 0x5d, 0x33, 0xbb, 0xa8, 0x5a, 0xf9, 0x53, 0xa8, 0xfb, 0x7e, 0xa8, 0xd6, 0x30, 0xde, 0xed, 0x6c, 0x58, 0x05, 0xbe, 0x1f, 0x1e, 0x29, 0x1f, 0x0c, 0xae, 0x32, 0x3b, 0x29, 0xe3, 0xf3, 0x50, 0x74, 0x6f, 0x49, 0x3a, 0x1a, 0x0a, 0xa4, 0x12, 0x23, 0x8f, 0xa1, 0xee, 0x26, 0x41, 0xce, 0x18, 0xe9, 0x1b, 0xdb, 0xad, 0x9d, 0xb7, 0x06, 0x99, 0xd6, 0xf7, 0xce, 0x8e, 0x34, 0x77, 0x14, 0xdc, 0x24, 0xc8, 0x78, 0xdc, 0x85, 0x5a, 0x12, 0x87, 0x81, 0x17, 0x30, 0xde, 0x7d, 0x4b, 0x46, 0xea, 0xed, 0xec, 0x53, 0xce, 0x42, 0xd7, 0x63, 0x33, 0x16, 0x89, 0x33, 0x74, 0x58, 0xd2, 0xdc, 0xf1, 0x33, 0xb3, 0x56, 0xea, 0x98, 0xd4, 0x4c, 0x5c, 0x31, 0xb1, 0xbf, 0x2e, 0x82, 0x89, 0x1f, 0x8c, 0x41, 0x8c, 0xdc, 0x19, 0x93, 0x3a, 0xb7, 0xa8, 0x1c, 0x93, 0x3b, 0x50, 0xe1, 0x13, 0x77, 0xe7, 0x83, 0x0f, 0xa5, 0xb2, 0x1b, 0x54, 0xcf, 0xc8, 0x5d, 0xb0, 0x94, 0x5a, 0xa7, 0x6c, 0xd9, 0x2d, 0x49, 0x53, 0x4d, 0x02, 0xc7, 0x6c, 0x49, 0xde, 0x86, 0x2a, 0xaa, 0x14, 0x4d, 0xa6, 0x5a, 0xc5, 0x22, 0x1f, 0x0d, 0xdf, 0x8d, 0xc6, 0x7b, 0x50, 0xf3, 0x52, 0xef, 0xc3, 0xc7, 0x2f, 0xe2, 0xb4, 0x5b, 0x95, 0xd6, 0x7c, 0x8e, 0xdf, 0x25, 0x62, 0xe1, 0x86, 0xce, 0x74, 0xc1, 0xa5, 0xaa, 0x4d, 0x5a, 0x93, 0xc0, 0xf1, 0x82, 0xe3, 0xce, 0xca, 0x38, 0x5a, 0x0a, 0xa9, 0x6b, 0xb9, 0xb3, 0x84, 0x86, 0x88, 0x90, 0x16, 0x14, 0xbd, 0xb1, 0x14, 0xb1, 0x45, 0x8b, 0xde, 0x18, 0x19, 0xe1, 0xc1, 0x97, 0x4c, 0x8a, 0xd7, 0xa4, 0x72, 0x8c, 0x27, 0x78, 0x41, 0x32, 0xc1, 0x92, 0xb0, 0x90, 0xca, 0x6d, 0xd0, 0x9a, 0x02, 0x8e, 0x16, 0xf6, 0x3f, 0x0c, 0xa8, 0x65, 0x02, 0x20, 0xef, 0x01, 0xcc, 0x98, 0x70, 0x1d, 0x95, 0xfa, 0xc6, 0x35, 0xa9, 0x6f, 0xcd, 0xb4, 0x2f, 0x47, 0x67, 0xdf, 0xcd, 0x9d, 0x8b, 0xd7, 0x39, 0xa3, 0x5d, 0x39, 0xaf, 0x64, 0x79, 0xe9, 0xe6, 0x2c, 0x5f, 0xcf, 0x64, 0xf3, 0xcd, 0x33, 0xb9, 0xdc, 0x2f, 0x65, 0x99, 0x6c, 0x3f, 0x84, 0xf6, 0x15, 0x29, 0xa1, 0x5b, 0x10, 0x8d, 0x63, 0xa9, 0x95, 0x06, 0x95, 0x63, 0xfb, 0x6b, 0x03, 0x2a, 0xea, 0x7c, 0x24, 0xd2, 0x1f, 0x69, 0x63, 0xd1, 0x1f, 0x91, 0xdb, 0x50, 0x16, 0xee, 0x28, 0x64, 0x5a, 0x45, 0x6a, 0xb2, 0x16, 0xc8, 0xd2, 0x4d, 0x81, 0x34, 0x6f, 0x0e, 0x64, 0xf9, 0x95, 0x40, 0xfe, 0x18, 0x3a, 0x22, 0x18, 0x87, 0x2e, 0x9f, 0x38, 0x29, 0x4b, 0xc2, 0xc0, 0x73, 0xb9, 0x14, 0x52, 0x93, 0xb6, 0x35, 0x4e, 0x35, 0x8c, 0x9f, 0xc6, 0x85, 0x2b, 0xb8, 0x94, 0x52, 0x83, 0xaa, 0x89, 0x7d, 0x06, 0xb5, 0x8c, 0x9d, 0x75, 0xad, 0x1b, 0x9b, 0xb5, 0x5e, 0x5c, 0xd3, 0xba, 0xd2, 0x52, 0x29, 0xd3, 0x92, 0xfd, 0x14, 0x5a, 0xfb, 0xba, 0x73, 0x3c, 0x3d, 0xc0, 0x7e, 0x85, 0x15, 0xd0, 0x9b, 0xa7, 0x29, 0x8b, 0x84, 0x6e, 0x2d, 0xd9, 0x14, 0x2d, 0x29, 0xfb, 0xfd, 0x9c, 0x71, 0x21, 0x37, 0x35, 0x69, 0x36, 0xb5, 0xff, 0x6e, 0x40, 0x59, 0xad, 0xee, 0x40, 0x69, 0xc6, 0x2f, 0x74, 0xb2, 0xe2, 0x90, 0x0c, 0xa1, 0x73, 0xd9, 0xad, 0x1c, 0xd9, 0x13, 0xe5, 0xf9, 0xf5, 0x9d, 0x3b, 0x59, 0xc4, 0xd7, 0xbf, 0xe0, 0xb0, 0x90, 0x77, 0xaa, 0x23, 0x5f, 0xed, 0x3a, 0x80, 0xda, 0x74, 0xa1, 0xd7, 0x9a, 0x72, 0xed, 0xad, 0xbc, 0x00, 0x1d, 0xb3, 0x65, 0xb6, 0xac, 0x3a, 0x5d, 0x28, 0xff, 0x5d, 0x68, 0xa4, 0xec, 0x22, 0x88, 0x23, 0xbd, 0xa6, 0x2c, 0xd7, 0xb4, 0x06, 0x59, 0x47, 0xce, 0x16, 0xd4, 0x95, 0x97, 0x9c, 0x0e, 0x6b, 0x50, 0xf1, 0x99, 0x70, 0x83, 0xd0, 0x0e, 0x01, 0xf6, 0x55, 0xee, 0x44, 0xe3, 0x98, 0x7c, 0x0c, 0x75, 0x9d, 0x5a, 0x62, 0x99, 0xa8, 0x3a, 0xd4, 0xda, 0xd9, 0x1a, 0xac, 0xb5, 0xf3, 0x83, 0x7c, 0xf2, 0x39, 0x13, 0x93, 0xd8, 0xa7, 0xa0, 0x96, 0x7c, 0xb1, 0x4c, 0x98, 0xec, 0xd7, 0x6a, 0x83, 0xcb, 0x78, 0xe8, 0x6c, 0x3d, 0x66, 0x4b, 0xfb, 0x0f, 0x26, 0x34, 0x87, 0xba, 0xe2, 0x4a, 0x3a, 0x5f, 0xd7, 0xe0, 0xd7, 0x22, 0x5f, 0xdc, 0x1c, 0xf9, 0xd2, 0xcd, 0x55, 0xce, 0x7c, 0x7d, 0x95, 0x2b, 0xbf, 0x52, 0xe5, 0xee, 0x61, 0xe6, 0x0a, 0xe6, 0x84, 0xc1, 0x2c, 0x10, 0xba, 0xce, 0x59, 0x88, 0x9c, 0x20, 0x40, 0xfa, 0x50, 0xf7, 0xe2, 0x48, 0x09, 0xc6, 0x5b, 0xca, 0x52, 0xd7, 0xa4, 0xab, 0x10, 0xf9, 0x18, 0xda, 0x5c, 0xc4, 0xa9, 0x7b, 0xc1, 0x1c, 0x8c, 0x3e, 0x8b, 0x7c, 0x59, 0xf1, 0x56, 0xd4, 0x70, 0xae, 0xcc, 0x43, 0x65, 0xa5, 0x2d, 0xbe, 0x36, 0x5f, 0x7f, 0x21, 0xc0, 0xfa, 0x0b, 0x41, 0xa9, 0xbb, 0x9e, 0x57, 0x4a, 0xd4, 0x5e, 0x3c, 0x4b, 0x52, 0xc6, 0xf1, 0xe3, 0x55, 0xfc, 0x1a, 0x32, 0x7e, 0x79, 0x37, 0xda, 0xbf, 0xb4, 0x63, 0xb0, 0x68, 0xdb, 0x5b, 0x07, 0xc8, 0x7b, 0x70, 0x6b, 0x75, 0x8f, 0x90, 0x2d, 0x58, 0x28, 0xdb, 0x7f, 0x99, 0xae, 0x6e, 0x7e, 0x82, 0x38, 0xd9, 0xcd, 0xb5, 0x22, 0xeb, 0x90, 0x6a, 0xf9, 0x24, 0x3f, 0x2b, 0x17, 0x55, 0xa6, 0x0f, 0x1c, 0x7f, 0x66, 0xd6, 0x2a, 0x9d, 0xaa, 0x6e, 0x7b, 0xdf, 0x16, 0xa1, 0xb5, 0x4e, 0x00, 0xb1, 0xc1, 0x8c, 0xe2, 0x38, 0x91, 0x3a, 0x58, 0xa9, 0xbe, 0xa7, 0x71, 0x9c, 0x1c, 0x16, 0xa8, 0xb4, 0x91, 0x87, 0x50, 0x0e, 0x63, 0xcf, 0x0d, 0xa5, 0x1c, 0xea, 0x3b, 0xcd, 0xcc, 0xe9, 0x04, 0xc1, 0xc3, 0x02, 0x55, 0x56, 0xf2, 0x43, 0x28, 0xf2, 0x5d, 0x9d, 0x7d, 0x90, 0xf3, 0xbd, 0x7b, 0x58, 0xa0, 0x45, 0xbe, 0x4b, 0xee, 0x43, 0xe9, 0xc2, 0xe3, 0x3a, 0xc1, 0xea, 0x99, 0xf9, 0xd3, 0xfd, 0xf3, 0xc3, 0x02, 0x45, 0x0b, 0xf9, 0x08, 0x9a, 0x5e, 0x18, 0xcf, 0x7d, 0xc7, 0x5f, 0x46, 0xee, 0x2c, 0xf0, 0x74, 0x5e, 0xdd, 0xbe, 0xcc, 0xe3, 0x78, 0xee, 0x3f, 0x55, 0xb6, 0xc3, 0x02, 0x6d, 0x78, 0x2b, 0x73, 0xbc, 0xc6, 0xc4, 0x1f, 0xab, 0x82, 0xb7, 0x72, 0x8d, 0xc3, 0xa7, 0x9f, 0xe0, 0xfe, 0xd2, 0x46, 0x0e, 0x81, 0xb8, 0x5f, 0xce, 0x53, 0xe6, 0x8c, 0xc2, 0x78, 0xe4, 0xe8, 0xc0, 0x4b, 0x95, 0xd5, 0x77, 0xba, 0xd9, 0x8a, 0x3d, 0xf4, 0x18, 0x86, 0xf1, 0x48, 0xf3, 0x74, 0x58, 0xa0, 0x1d, 0xf7, 0x0a, 0x36, 0xb4, 0xa0, 0xaa, 0xe5, 0x65, 0x57, 0xc0, 0x44, 0xae, 0xec, 0xbb, 0x50, 0x96, 0x74, 0x60, 0x97, 0x40, 0xae, 0xb3, 0x17, 0x85, 0xe4, 0xfd, 0x9b, 0x22, 0x14, 0xcf, 0x77, 0xb1, 0xf6, 0xb3, 0xc8, 0x4f, 0xe2, 0x40, 0x57, 0x3f, 0x8b, 0xe6, 0x73, 0x7c, 0x74, 0xa8, 0x72, 0xa1, 0x9f, 0xd3, 0x7a, 0x86, 0xf8, 0x68, 0xee, 0x4d, 0x99, 0xd0, 0x65, 0x55, 0xcf, 0x10, 0x4f, 0x52, 0x36, 0x0e, 0x5e, 0x48, 0x46, 0x2d, 0xaa, 0x67, 0x2a, 0x11, 0x55, 0x06, 0x78, 0xa1, 0xcb, 0x55, 0xa3, 0xb0, 0x30, 0x11, 0x25, 0xb8, 0x8f, 0x18, 0xd6, 0x51, 0xce, 0x99, 0x24, 0xcb, 0xa2, 0x38, 0x44, 0xc4, 0xf5, 0x42, 0x49, 0x86, 0x45, 0x71, 0x88, 0xb9, 0xe8, 0x7a, 0x1e, 0xe3, 0x5c, 0x66, 0x7b, 0x4d, 0x3d, 0x65, 0x15, 0x82, 0x09, 0xff, 0x2e, 0xdc, 0xe2, 0xcc, 0x4b, 0x99, 0x70, 0x56, 0xbc, 0x2c, 0xe9, 0xd5, 0x56, 0x86, 0xbd, 0xdc, 0x77, 0x1b, 0x3a, 0xe3, 0x38, 0xf5, 0x98, 0x83, 0x64, 0x38, 0x5c, 0x2c, 0x43, 0xa6, 0x73, 0xab, 0x25, 0xf1, 0x33, 0x57, 0x4c, 0xce, 0x11, 0x25, 0x0f, 0xa0, 0xc5, 0x39, 0x73, 0xa6, 0x33, 0xb9, 0x1f, 0xd6, 0x27, 0x95, 0x6e, 0x75, 0xce, 0xd9, 0xf1, 0x0c, 0x37, 0x3b, 0xf2, 0xed, 0xaf, 0x0c, 0x28, 0x7d, 0xba, 0x7f, 0xfe, 0x3a, 0x3a, 0x35, 0x6d, 0xc5, 0x0d, 0xb4, 0x95, 0x6e, 0xa6, 0xcd, 0xbc, 0x86, 0xb6, 0x87, 0xd0, 0x4a, 0x52, 0xe6, 0xb3, 0x71, 0x10, 0x31, 0xdf, 0x41, 0xbe, 0x14, 0xb9, 0xcd, 0x4b, 0x74, 0xcf, 0x0b, 0xb1, 0x11, 0x7b, 0x08, 0x44, 0x22, 0x70, 0x43, 0x2e, 0xd5, 0xa6, 0xa9, 0x6e, 0xaf, 0xe0, 0xa8, 0x27, 0xfb, 0x6f, 0x06, 0x74, 0xae, 0x2a, 0xee, 0xfb, 0xbf, 0xd7, 0x3b, 0xd0, 0x70, 0x3d, 0x2f, 0x9e, 0x47, 0xc2, 0x91, 0x8f, 0x61, 0x75, 0xab, 0xba, 0xc6, 0x4e, 0xf1, 0x4d, 0x7c, 0x0f, 0x80, 0x4f, 0xdc, 0x94, 0xa9, 0xda, 0xaf, 0x6e, 0x63, 0x29, 0x04, 0xbb, 0xcc, 0x1f, 0x0d, 0xa8, 0x0c, 0xd5, 0x97, 0xbc, 0x99, 0xc8, 0x4b, 0x1b, 0x44, 0x6e, 0x6e, 0xb8, 0x55, 0xf9, 0xe6, 0x5b, 0x55, 0x5e, 0xbd, 0x15, 0x3e, 0x1b, 0x1a, 0xab, 0x35, 0x83, 0x3c, 0xca, 0x4f, 0x31, 0x74, 0xc7, 0xd6, 0x39, 0xaf, 0xbe, 0x3c, 0x3f, 0xf5, 0x01, 0x34, 0x93, 0x34, 0x5e, 0x04, 0x3e, 0x4b, 0x15, 0x1f, 0x8a, 0xea, 0x46, 0x06, 0x4a, 0x42, 0x3e, 0x80, 0xb2, 0x2b, 0x44, 0x9a, 0x3d, 0x46, 0xef, 0x5f, 0x57, 0xa5, 0x06, 0x7b, 0xe8, 0x71, 0x10, 0x89, 0x74, 0x49, 0x95, 0x77, 0xef, 0x09, 0xc0, 0x25, 0x88, 0x59, 0x97, 0xbd, 0xaf, 0x2c, 0x8a, 0x43, 0x7c, 0x99, 0x2d, 0xdc, 0x70, 0x9e, 0x9d, 0xa9, 0x26, 0x3f, 0x2b, 0x3e, 0x31, 0xec, 0x2d, 0x30, 0xb1, 0x9a, 0x29, 0x0e, 0x67, 0xb1, 0xc8, 0x7e, 0xb3, 0xe8, 0x19, 0x4a, 0xa9, 0x95, 0x35, 0x7a, 0x9e, 0xc4, 0x11, 0xc7, 0x6c, 0x2a, 0xab, 0x17, 0x8a, 0xb1, 0x5e, 0xb7, 0xe5, 0x8b, 0x84, 0x2a, 0xdb, 0xff, 0xd9, 0xef, 0xdf, 0xe4, 0xd7, 0xfd, 0x95, 0xdf, 0x76, 0xe5, 0x37, 0xfa, 0x6d, 0x67, 0x7f, 0x63, 0xc0, 0xbd, 0x83, 0x17, 0x82, 0xa5, 0x91, 0x1b, 0xea, 0x8c, 0xa0, 0x0c, 0x03, 0xcb, 0xb2, 0x07, 0xcc, 0x35, 0x4d, 0xde, 0xf8, 0x9f, 0x9a, 0xfc, 0x7d, 0xa8, 0xc7, 0xa3, 0xdf, 0x31, 0x4f, 0xac, 0x86, 0x17, 0x14, 0x24, 0x83, 0xfb, 0x0e, 0xbe, 0xf0, 0xe4, 0x99, 0xca, 0x43, 0xa9, 0xb5, 0xae, 0x31, 0xe9, 0xf2, 0x10, 0x5a, 0x5e, 0x1c, 0x09, 0x16, 0x09, 0x27, 0x64, 0xd1, 0x85, 0x98, 0xe8, 0x17, 0x4f, 0x53, 0xa3, 0x27, 0x12, 0xb4, 0xfb, 0xb0, 0xb5, 0xe9, 0x32, 0x2a, 0x48, 0xf6, 0x9f, 0x0d, 0xe8, 0x5d, 0x71, 0x39, 0x77, 0x17, 0xdf, 0xe3, 0x65, 0x5f, 0xbd, 0x49, 0xe9, 0xba, 0x9b, 0xdc, 0x83, 0xbb, 0xd7, 0x7e, 0xa6, 0xba, 0xc6, 0xbb, 0x3f, 0x87, 0xf6, 0x95, 0xc7, 0x0e, 0xa9, 0x43, 0xf5, 0x57, 0xa7, 0xc7, 0xa7, 0xbf, 0xf8, 0xcd, 0x69, 0xa7, 0x40, 0xaa, 0x50, 0x3a, 0x79, 0xf6, 0xb8, 0x63, 0x10, 0x80, 0xca, 0xf9, 0xe9, 0xde, 0xd9, 0xd9, 0x6f, 0x3b, 0x45, 0x52, 0x03, 0xf3, 0xd9, 0xf9, 0x17, 0x4f, 0x3b, 0xa5, 0x9d, 0x03, 0xa8, 0x28, 0xf1, 0x92, 0x8f, 0x40, 0xff, 0xc7, 0x8b, 0xfc, 0x20, 0xcf, 0xcf, 0xd5, 0xf7, 0x6b, 0xef, 0xce, 0x55, 0x58, 0x13, 0x59, 0xf8, 0x89, 0xb1, 0xf3, 0x57, 0x03, 0xda, 0x57, 0xbe, 0x92, 0x3c, 0xc3, 0x1f, 0x16, 0x92, 0x73, 0xf2, 0x30, 0xcf, 0x80, 0x9b, 0x04, 0xd6, 0x7b, 0xf4, 0x3a, 0xb7, 0xec, 0x44, 0xf2, 0x4b, 0x30, 0xb9, 0xbb, 0x60, 0xc4, 0xde, 0xb0, 0x62, 0x25, 0x92, 0xbd, 0x07, 0x37, 0xfa, 0x64, 0x5b, 0x0e, 0x1f, 0xfd, 0xf3, 0x2f, 0x35, 0xe3, 0xab, 0x97, 0x5b, 0xc6, 0xb7, 0x2f, 0xb7, 0x8c, 0x7f, 0xbd, 0xdc, 0x32, 0xfe, 0xf4, 0xef, 0xad, 0x02, 0x74, 0xe2, 0xf4, 0x62, 0x20, 0x82, 0xe9, 0x62, 0x30, 0x5d, 0xc8, 0x7f, 0xdb, 0x8d, 0x2a, 0xf2, 0xcf, 0xee, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x8d, 0x35, 0x92, 0x3d, 0x2c, 0x14, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/cdcpb/000077500000000000000000000000001421456440000161415ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/cdcpb/cdcpb.pb.go000066400000000000000000003773571421456440000201710ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: cdcpb.proto package cdcpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" metapb "github.com/pingcap/kvproto/pkg/metapb" raft_cmdpb "github.com/pingcap/kvproto/pkg/raft_cmdpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type Event_LogType int32 const ( Event_UNKNOWN Event_LogType = 0 Event_PREWRITE Event_LogType = 1 Event_COMMIT Event_LogType = 2 Event_ROLLBACK Event_LogType = 3 Event_COMMITTED Event_LogType = 4 Event_INITIALIZED Event_LogType = 5 ) var Event_LogType_name = map[int32]string{ 0: "UNKNOWN", 1: "PREWRITE", 2: "COMMIT", 3: "ROLLBACK", 4: "COMMITTED", 5: "INITIALIZED", } var Event_LogType_value = map[string]int32{ "UNKNOWN": 0, "PREWRITE": 1, "COMMIT": 2, "ROLLBACK": 3, "COMMITTED": 4, "INITIALIZED": 5, } func (x Event_LogType) String() string { return proto.EnumName(Event_LogType_name, int32(x)) } func (Event_LogType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 0} } type Event_Row_OpType int32 const ( Event_Row_UNKNOWN Event_Row_OpType = 0 Event_Row_PUT Event_Row_OpType = 1 Event_Row_DELETE Event_Row_OpType = 2 ) var Event_Row_OpType_name = map[int32]string{ 0: "UNKNOWN", 1: "PUT", 2: "DELETE", } var Event_Row_OpType_value = map[string]int32{ "UNKNOWN": 0, "PUT": 1, "DELETE": 2, } func (x Event_Row_OpType) String() string { return proto.EnumName(Event_Row_OpType_name, int32(x)) } func (Event_Row_OpType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 0, 0} } // KvAPI specifies to capture data written by different KV API. // See more details in https://github.com/tikv/rfcs/blob/master/text/0069-api-v2.md. type ChangeDataRequest_KvAPI int32 const ( ChangeDataRequest_TiBD ChangeDataRequest_KvAPI = 0 ChangeDataRequest_RawKV ChangeDataRequest_KvAPI = 1 ChangeDataRequest_TxnKV ChangeDataRequest_KvAPI = 2 ) var ChangeDataRequest_KvAPI_name = map[int32]string{ 0: "TiBD", 1: "RawKV", 2: "TxnKV", } var ChangeDataRequest_KvAPI_value = map[string]int32{ "TiBD": 0, "RawKV": 1, "TxnKV": 2, } func (x ChangeDataRequest_KvAPI) String() string { return proto.EnumName(ChangeDataRequest_KvAPI_name, int32(x)) } func (ChangeDataRequest_KvAPI) EnumDescriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{10, 0} } type Header struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` TicdcVersion string `protobuf:"bytes,2,opt,name=ticdc_version,json=ticdcVersion,proto3" json:"ticdc_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{0} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Header.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Header) XXX_Merge(src proto.Message) { xxx_messageInfo_Header.Merge(dst, src) } func (m *Header) XXX_Size() int { return m.Size() } func (m *Header) XXX_DiscardUnknown() { xxx_messageInfo_Header.DiscardUnknown(m) } var xxx_messageInfo_Header proto.InternalMessageInfo func (m *Header) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *Header) GetTicdcVersion() string { if m != nil { return m.TicdcVersion } return "" } type DuplicateRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DuplicateRequest) Reset() { *m = DuplicateRequest{} } func (m *DuplicateRequest) String() string { return proto.CompactTextString(m) } func (*DuplicateRequest) ProtoMessage() {} func (*DuplicateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{1} } func (m *DuplicateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DuplicateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DuplicateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DuplicateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DuplicateRequest.Merge(dst, src) } func (m *DuplicateRequest) XXX_Size() int { return m.Size() } func (m *DuplicateRequest) XXX_DiscardUnknown() { xxx_messageInfo_DuplicateRequest.DiscardUnknown(m) } var xxx_messageInfo_DuplicateRequest proto.InternalMessageInfo func (m *DuplicateRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type Compatibility struct { RequiredVersion string `protobuf:"bytes,1,opt,name=required_version,json=requiredVersion,proto3" json:"required_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Compatibility) Reset() { *m = Compatibility{} } func (m *Compatibility) String() string { return proto.CompactTextString(m) } func (*Compatibility) ProtoMessage() {} func (*Compatibility) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{2} } func (m *Compatibility) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Compatibility) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Compatibility.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Compatibility) XXX_Merge(src proto.Message) { xxx_messageInfo_Compatibility.Merge(dst, src) } func (m *Compatibility) XXX_Size() int { return m.Size() } func (m *Compatibility) XXX_DiscardUnknown() { xxx_messageInfo_Compatibility.DiscardUnknown(m) } var xxx_messageInfo_Compatibility proto.InternalMessageInfo func (m *Compatibility) GetRequiredVersion() string { if m != nil { return m.RequiredVersion } return "" } // ClusterIDMismatch is an error variable that // tells people that the cluster ID of the request does not match the TiKV cluster ID. type ClusterIDMismatch struct { // The current tikv cluster ID. Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"` // The cluster ID of the TiCDC request. Request uint64 `protobuf:"varint,2,opt,name=request,proto3" json:"request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ClusterIDMismatch) Reset() { *m = ClusterIDMismatch{} } func (m *ClusterIDMismatch) String() string { return proto.CompactTextString(m) } func (*ClusterIDMismatch) ProtoMessage() {} func (*ClusterIDMismatch) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{3} } func (m *ClusterIDMismatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ClusterIDMismatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ClusterIDMismatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ClusterIDMismatch) XXX_Merge(src proto.Message) { xxx_messageInfo_ClusterIDMismatch.Merge(dst, src) } func (m *ClusterIDMismatch) XXX_Size() int { return m.Size() } func (m *ClusterIDMismatch) XXX_DiscardUnknown() { xxx_messageInfo_ClusterIDMismatch.DiscardUnknown(m) } var xxx_messageInfo_ClusterIDMismatch proto.InternalMessageInfo func (m *ClusterIDMismatch) GetCurrent() uint64 { if m != nil { return m.Current } return 0 } func (m *ClusterIDMismatch) GetRequest() uint64 { if m != nil { return m.Request } return 0 } type Error struct { NotLeader *errorpb.NotLeader `protobuf:"bytes,1,opt,name=not_leader,json=notLeader" json:"not_leader,omitempty"` RegionNotFound *errorpb.RegionNotFound `protobuf:"bytes,2,opt,name=region_not_found,json=regionNotFound" json:"region_not_found,omitempty"` EpochNotMatch *errorpb.EpochNotMatch `protobuf:"bytes,3,opt,name=epoch_not_match,json=epochNotMatch" json:"epoch_not_match,omitempty"` DuplicateRequest *DuplicateRequest `protobuf:"bytes,4,opt,name=duplicate_request,json=duplicateRequest" json:"duplicate_request,omitempty"` Compatibility *Compatibility `protobuf:"bytes,5,opt,name=compatibility" json:"compatibility,omitempty"` ClusterIdMismatch *ClusterIDMismatch `protobuf:"bytes,6,opt,name=cluster_id_mismatch,json=clusterIdMismatch" json:"cluster_id_mismatch,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{4} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetNotLeader() *errorpb.NotLeader { if m != nil { return m.NotLeader } return nil } func (m *Error) GetRegionNotFound() *errorpb.RegionNotFound { if m != nil { return m.RegionNotFound } return nil } func (m *Error) GetEpochNotMatch() *errorpb.EpochNotMatch { if m != nil { return m.EpochNotMatch } return nil } func (m *Error) GetDuplicateRequest() *DuplicateRequest { if m != nil { return m.DuplicateRequest } return nil } func (m *Error) GetCompatibility() *Compatibility { if m != nil { return m.Compatibility } return nil } func (m *Error) GetClusterIdMismatch() *ClusterIDMismatch { if m != nil { return m.ClusterIdMismatch } return nil } type TxnInfo struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Primary []byte `protobuf:"bytes,2,opt,name=primary,proto3" json:"primary,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnInfo) Reset() { *m = TxnInfo{} } func (m *TxnInfo) String() string { return proto.CompactTextString(m) } func (*TxnInfo) ProtoMessage() {} func (*TxnInfo) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{5} } func (m *TxnInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnInfo.Merge(dst, src) } func (m *TxnInfo) XXX_Size() int { return m.Size() } func (m *TxnInfo) XXX_DiscardUnknown() { xxx_messageInfo_TxnInfo.DiscardUnknown(m) } var xxx_messageInfo_TxnInfo proto.InternalMessageInfo func (m *TxnInfo) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *TxnInfo) GetPrimary() []byte { if m != nil { return m.Primary } return nil } type TxnStatus struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` MinCommitTs uint64 `protobuf:"varint,2,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` IsRolledBack bool `protobuf:"varint,4,opt,name=is_rolled_back,json=isRolledBack,proto3" json:"is_rolled_back,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnStatus) Reset() { *m = TxnStatus{} } func (m *TxnStatus) String() string { return proto.CompactTextString(m) } func (*TxnStatus) ProtoMessage() {} func (*TxnStatus) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{6} } func (m *TxnStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnStatus.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnStatus.Merge(dst, src) } func (m *TxnStatus) XXX_Size() int { return m.Size() } func (m *TxnStatus) XXX_DiscardUnknown() { xxx_messageInfo_TxnStatus.DiscardUnknown(m) } var xxx_messageInfo_TxnStatus proto.InternalMessageInfo func (m *TxnStatus) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *TxnStatus) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } func (m *TxnStatus) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *TxnStatus) GetIsRolledBack() bool { if m != nil { return m.IsRolledBack } return false } type Event struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` RequestId uint64 `protobuf:"varint,7,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` // Types that are valid to be assigned to Event: // *Event_Entries_ // *Event_Admin_ // *Event_Error // *Event_ResolvedTs // *Event_LongTxn_ Event isEvent_Event `protobuf_oneof:"event"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Event) Reset() { *m = Event{} } func (m *Event) String() string { return proto.CompactTextString(m) } func (*Event) ProtoMessage() {} func (*Event) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7} } func (m *Event) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Event.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Event) XXX_Merge(src proto.Message) { xxx_messageInfo_Event.Merge(dst, src) } func (m *Event) XXX_Size() int { return m.Size() } func (m *Event) XXX_DiscardUnknown() { xxx_messageInfo_Event.DiscardUnknown(m) } var xxx_messageInfo_Event proto.InternalMessageInfo type isEvent_Event interface { isEvent_Event() MarshalTo([]byte) (int, error) Size() int } type Event_Entries_ struct { Entries *Event_Entries `protobuf:"bytes,3,opt,name=entries,oneof"` } type Event_Admin_ struct { Admin *Event_Admin `protobuf:"bytes,4,opt,name=admin,oneof"` } type Event_Error struct { Error *Error `protobuf:"bytes,5,opt,name=error,oneof"` } type Event_ResolvedTs struct { ResolvedTs uint64 `protobuf:"varint,6,opt,name=resolved_ts,json=resolvedTs,proto3,oneof"` } type Event_LongTxn_ struct { LongTxn *Event_LongTxn `protobuf:"bytes,8,opt,name=long_txn,json=longTxn,oneof"` } func (*Event_Entries_) isEvent_Event() {} func (*Event_Admin_) isEvent_Event() {} func (*Event_Error) isEvent_Event() {} func (*Event_ResolvedTs) isEvent_Event() {} func (*Event_LongTxn_) isEvent_Event() {} func (m *Event) GetEvent() isEvent_Event { if m != nil { return m.Event } return nil } func (m *Event) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *Event) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *Event) GetRequestId() uint64 { if m != nil { return m.RequestId } return 0 } func (m *Event) GetEntries() *Event_Entries { if x, ok := m.GetEvent().(*Event_Entries_); ok { return x.Entries } return nil } func (m *Event) GetAdmin() *Event_Admin { if x, ok := m.GetEvent().(*Event_Admin_); ok { return x.Admin } return nil } func (m *Event) GetError() *Error { if x, ok := m.GetEvent().(*Event_Error); ok { return x.Error } return nil } // Deprecated: Do not use. func (m *Event) GetResolvedTs() uint64 { if x, ok := m.GetEvent().(*Event_ResolvedTs); ok { return x.ResolvedTs } return 0 } func (m *Event) GetLongTxn() *Event_LongTxn { if x, ok := m.GetEvent().(*Event_LongTxn_); ok { return x.LongTxn } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*Event) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _Event_OneofMarshaler, _Event_OneofUnmarshaler, _Event_OneofSizer, []interface{}{ (*Event_Entries_)(nil), (*Event_Admin_)(nil), (*Event_Error)(nil), (*Event_ResolvedTs)(nil), (*Event_LongTxn_)(nil), } } func _Event_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Event) // event switch x := m.Event.(type) { case *Event_Entries_: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Entries); err != nil { return err } case *Event_Admin_: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Admin); err != nil { return err } case *Event_Error: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Error); err != nil { return err } case *Event_ResolvedTs: _ = b.EncodeVarint(6<<3 | proto.WireVarint) _ = b.EncodeVarint(uint64(x.ResolvedTs)) case *Event_LongTxn_: _ = b.EncodeVarint(8<<3 | proto.WireBytes) if err := b.EncodeMessage(x.LongTxn); err != nil { return err } case nil: default: return fmt.Errorf("Event.Event has unexpected type %T", x) } return nil } func _Event_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Event) switch tag { case 3: // event.entries if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Event_Entries) err := b.DecodeMessage(msg) m.Event = &Event_Entries_{msg} return true, err case 4: // event.admin if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Event_Admin) err := b.DecodeMessage(msg) m.Event = &Event_Admin_{msg} return true, err case 5: // event.error if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Error) err := b.DecodeMessage(msg) m.Event = &Event_Error{msg} return true, err case 6: // event.resolved_ts if wire != proto.WireVarint { return true, proto.ErrInternalBadWireType } x, err := b.DecodeVarint() m.Event = &Event_ResolvedTs{x} return true, err case 8: // event.long_txn if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Event_LongTxn) err := b.DecodeMessage(msg) m.Event = &Event_LongTxn_{msg} return true, err default: return false, nil } } func _Event_OneofSizer(msg proto.Message) (n int) { m := msg.(*Event) // event switch x := m.Event.(type) { case *Event_Entries_: s := proto.Size(x.Entries) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Event_Admin_: s := proto.Size(x.Admin) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Event_Error: s := proto.Size(x.Error) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Event_ResolvedTs: n += 1 // tag and wire n += proto.SizeVarint(uint64(x.ResolvedTs)) case *Event_LongTxn_: s := proto.Size(x.LongTxn) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type Event_Row struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` CommitTs uint64 `protobuf:"varint,2,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` Type Event_LogType `protobuf:"varint,3,opt,name=type,proto3,enum=cdcpb.Event_LogType" json:"type,omitempty"` OpType Event_Row_OpType `protobuf:"varint,4,opt,name=op_type,json=opType,proto3,enum=cdcpb.Event_Row_OpType" json:"op_type,omitempty"` Key []byte `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"` OldValue []byte `protobuf:"bytes,7,opt,name=old_value,json=oldValue,proto3" json:"old_value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Event_Row) Reset() { *m = Event_Row{} } func (m *Event_Row) String() string { return proto.CompactTextString(m) } func (*Event_Row) ProtoMessage() {} func (*Event_Row) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 0} } func (m *Event_Row) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Event_Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Event_Row.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Event_Row) XXX_Merge(src proto.Message) { xxx_messageInfo_Event_Row.Merge(dst, src) } func (m *Event_Row) XXX_Size() int { return m.Size() } func (m *Event_Row) XXX_DiscardUnknown() { xxx_messageInfo_Event_Row.DiscardUnknown(m) } var xxx_messageInfo_Event_Row proto.InternalMessageInfo func (m *Event_Row) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *Event_Row) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *Event_Row) GetType() Event_LogType { if m != nil { return m.Type } return Event_UNKNOWN } func (m *Event_Row) GetOpType() Event_Row_OpType { if m != nil { return m.OpType } return Event_Row_UNKNOWN } func (m *Event_Row) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *Event_Row) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *Event_Row) GetOldValue() []byte { if m != nil { return m.OldValue } return nil } type Event_Entries struct { Entries []*Event_Row `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Event_Entries) Reset() { *m = Event_Entries{} } func (m *Event_Entries) String() string { return proto.CompactTextString(m) } func (*Event_Entries) ProtoMessage() {} func (*Event_Entries) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 1} } func (m *Event_Entries) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Event_Entries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Event_Entries.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Event_Entries) XXX_Merge(src proto.Message) { xxx_messageInfo_Event_Entries.Merge(dst, src) } func (m *Event_Entries) XXX_Size() int { return m.Size() } func (m *Event_Entries) XXX_DiscardUnknown() { xxx_messageInfo_Event_Entries.DiscardUnknown(m) } var xxx_messageInfo_Event_Entries proto.InternalMessageInfo func (m *Event_Entries) GetEntries() []*Event_Row { if m != nil { return m.Entries } return nil } type Event_Admin struct { AdminRequest *raft_cmdpb.AdminRequest `protobuf:"bytes,1,opt,name=admin_request,json=adminRequest" json:"admin_request,omitempty"` AdminResponse *raft_cmdpb.AdminResponse `protobuf:"bytes,2,opt,name=admin_response,json=adminResponse" json:"admin_response,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Event_Admin) Reset() { *m = Event_Admin{} } func (m *Event_Admin) String() string { return proto.CompactTextString(m) } func (*Event_Admin) ProtoMessage() {} func (*Event_Admin) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 2} } func (m *Event_Admin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Event_Admin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Event_Admin.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Event_Admin) XXX_Merge(src proto.Message) { xxx_messageInfo_Event_Admin.Merge(dst, src) } func (m *Event_Admin) XXX_Size() int { return m.Size() } func (m *Event_Admin) XXX_DiscardUnknown() { xxx_messageInfo_Event_Admin.DiscardUnknown(m) } var xxx_messageInfo_Event_Admin proto.InternalMessageInfo func (m *Event_Admin) GetAdminRequest() *raft_cmdpb.AdminRequest { if m != nil { return m.AdminRequest } return nil } func (m *Event_Admin) GetAdminResponse() *raft_cmdpb.AdminResponse { if m != nil { return m.AdminResponse } return nil } type Event_LongTxn struct { TxnInfo []*TxnInfo `protobuf:"bytes,1,rep,name=txn_info,json=txnInfo" json:"txn_info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Event_LongTxn) Reset() { *m = Event_LongTxn{} } func (m *Event_LongTxn) String() string { return proto.CompactTextString(m) } func (*Event_LongTxn) ProtoMessage() {} func (*Event_LongTxn) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 3} } func (m *Event_LongTxn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Event_LongTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Event_LongTxn.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Event_LongTxn) XXX_Merge(src proto.Message) { xxx_messageInfo_Event_LongTxn.Merge(dst, src) } func (m *Event_LongTxn) XXX_Size() int { return m.Size() } func (m *Event_LongTxn) XXX_DiscardUnknown() { xxx_messageInfo_Event_LongTxn.DiscardUnknown(m) } var xxx_messageInfo_Event_LongTxn proto.InternalMessageInfo func (m *Event_LongTxn) GetTxnInfo() []*TxnInfo { if m != nil { return m.TxnInfo } return nil } type ChangeDataEvent struct { Events []*Event `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"` ResolvedTs *ResolvedTs `protobuf:"bytes,2,opt,name=resolved_ts,json=resolvedTs" json:"resolved_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangeDataEvent) Reset() { *m = ChangeDataEvent{} } func (m *ChangeDataEvent) String() string { return proto.CompactTextString(m) } func (*ChangeDataEvent) ProtoMessage() {} func (*ChangeDataEvent) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{8} } func (m *ChangeDataEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangeDataEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangeDataEvent.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangeDataEvent) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangeDataEvent.Merge(dst, src) } func (m *ChangeDataEvent) XXX_Size() int { return m.Size() } func (m *ChangeDataEvent) XXX_DiscardUnknown() { xxx_messageInfo_ChangeDataEvent.DiscardUnknown(m) } var xxx_messageInfo_ChangeDataEvent proto.InternalMessageInfo func (m *ChangeDataEvent) GetEvents() []*Event { if m != nil { return m.Events } return nil } func (m *ChangeDataEvent) GetResolvedTs() *ResolvedTs { if m != nil { return m.ResolvedTs } return nil } type ResolvedTs struct { Regions []uint64 `protobuf:"varint,1,rep,packed,name=regions" json:"regions,omitempty"` Ts uint64 `protobuf:"varint,2,opt,name=ts,proto3" json:"ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResolvedTs) Reset() { *m = ResolvedTs{} } func (m *ResolvedTs) String() string { return proto.CompactTextString(m) } func (*ResolvedTs) ProtoMessage() {} func (*ResolvedTs) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{9} } func (m *ResolvedTs) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResolvedTs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResolvedTs.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResolvedTs) XXX_Merge(src proto.Message) { xxx_messageInfo_ResolvedTs.Merge(dst, src) } func (m *ResolvedTs) XXX_Size() int { return m.Size() } func (m *ResolvedTs) XXX_DiscardUnknown() { xxx_messageInfo_ResolvedTs.DiscardUnknown(m) } var xxx_messageInfo_ResolvedTs proto.InternalMessageInfo func (m *ResolvedTs) GetRegions() []uint64 { if m != nil { return m.Regions } return nil } func (m *ResolvedTs) GetTs() uint64 { if m != nil { return m.Ts } return 0 } type ChangeDataRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,3,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` CheckpointTs uint64 `protobuf:"varint,4,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"` StartKey []byte `protobuf:"bytes,5,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,6,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // Used for CDC to identify events corresponding to different requests. RequestId uint64 `protobuf:"varint,7,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` ExtraOp kvrpcpb.ExtraOp `protobuf:"varint,8,opt,name=extra_op,json=extraOp,proto3,enum=kvrpcpb.ExtraOp" json:"extra_op,omitempty"` // Types that are valid to be assigned to Request: // *ChangeDataRequest_Register_ // *ChangeDataRequest_NotifyTxnStatus_ Request isChangeDataRequest_Request `protobuf_oneof:"request"` KvApi ChangeDataRequest_KvAPI `protobuf:"varint,11,opt,name=kv_api,json=kvApi,proto3,enum=cdcpb.ChangeDataRequest_KvAPI" json:"kv_api,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangeDataRequest) Reset() { *m = ChangeDataRequest{} } func (m *ChangeDataRequest) String() string { return proto.CompactTextString(m) } func (*ChangeDataRequest) ProtoMessage() {} func (*ChangeDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{10} } func (m *ChangeDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangeDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangeDataRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangeDataRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangeDataRequest.Merge(dst, src) } func (m *ChangeDataRequest) XXX_Size() int { return m.Size() } func (m *ChangeDataRequest) XXX_DiscardUnknown() { xxx_messageInfo_ChangeDataRequest.DiscardUnknown(m) } var xxx_messageInfo_ChangeDataRequest proto.InternalMessageInfo type isChangeDataRequest_Request interface { isChangeDataRequest_Request() MarshalTo([]byte) (int, error) Size() int } type ChangeDataRequest_Register_ struct { Register *ChangeDataRequest_Register `protobuf:"bytes,9,opt,name=register,oneof"` } type ChangeDataRequest_NotifyTxnStatus_ struct { NotifyTxnStatus *ChangeDataRequest_NotifyTxnStatus `protobuf:"bytes,10,opt,name=notify_txn_status,json=notifyTxnStatus,oneof"` } func (*ChangeDataRequest_Register_) isChangeDataRequest_Request() {} func (*ChangeDataRequest_NotifyTxnStatus_) isChangeDataRequest_Request() {} func (m *ChangeDataRequest) GetRequest() isChangeDataRequest_Request { if m != nil { return m.Request } return nil } func (m *ChangeDataRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *ChangeDataRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *ChangeDataRequest) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *ChangeDataRequest) GetCheckpointTs() uint64 { if m != nil { return m.CheckpointTs } return 0 } func (m *ChangeDataRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *ChangeDataRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *ChangeDataRequest) GetRequestId() uint64 { if m != nil { return m.RequestId } return 0 } func (m *ChangeDataRequest) GetExtraOp() kvrpcpb.ExtraOp { if m != nil { return m.ExtraOp } return kvrpcpb.ExtraOp_Noop } func (m *ChangeDataRequest) GetRegister() *ChangeDataRequest_Register { if x, ok := m.GetRequest().(*ChangeDataRequest_Register_); ok { return x.Register } return nil } func (m *ChangeDataRequest) GetNotifyTxnStatus() *ChangeDataRequest_NotifyTxnStatus { if x, ok := m.GetRequest().(*ChangeDataRequest_NotifyTxnStatus_); ok { return x.NotifyTxnStatus } return nil } func (m *ChangeDataRequest) GetKvApi() ChangeDataRequest_KvAPI { if m != nil { return m.KvApi } return ChangeDataRequest_TiBD } // XXX_OneofFuncs is for the internal use of the proto package. func (*ChangeDataRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _ChangeDataRequest_OneofMarshaler, _ChangeDataRequest_OneofUnmarshaler, _ChangeDataRequest_OneofSizer, []interface{}{ (*ChangeDataRequest_Register_)(nil), (*ChangeDataRequest_NotifyTxnStatus_)(nil), } } func _ChangeDataRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*ChangeDataRequest) // request switch x := m.Request.(type) { case *ChangeDataRequest_Register_: _ = b.EncodeVarint(9<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Register); err != nil { return err } case *ChangeDataRequest_NotifyTxnStatus_: _ = b.EncodeVarint(10<<3 | proto.WireBytes) if err := b.EncodeMessage(x.NotifyTxnStatus); err != nil { return err } case nil: default: return fmt.Errorf("ChangeDataRequest.Request has unexpected type %T", x) } return nil } func _ChangeDataRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*ChangeDataRequest) switch tag { case 9: // request.register if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(ChangeDataRequest_Register) err := b.DecodeMessage(msg) m.Request = &ChangeDataRequest_Register_{msg} return true, err case 10: // request.notify_txn_status if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(ChangeDataRequest_NotifyTxnStatus) err := b.DecodeMessage(msg) m.Request = &ChangeDataRequest_NotifyTxnStatus_{msg} return true, err default: return false, nil } } func _ChangeDataRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*ChangeDataRequest) // request switch x := m.Request.(type) { case *ChangeDataRequest_Register_: s := proto.Size(x.Register) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *ChangeDataRequest_NotifyTxnStatus_: s := proto.Size(x.NotifyTxnStatus) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type ChangeDataRequest_Register struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangeDataRequest_Register) Reset() { *m = ChangeDataRequest_Register{} } func (m *ChangeDataRequest_Register) String() string { return proto.CompactTextString(m) } func (*ChangeDataRequest_Register) ProtoMessage() {} func (*ChangeDataRequest_Register) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{10, 0} } func (m *ChangeDataRequest_Register) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangeDataRequest_Register) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangeDataRequest_Register.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangeDataRequest_Register) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangeDataRequest_Register.Merge(dst, src) } func (m *ChangeDataRequest_Register) XXX_Size() int { return m.Size() } func (m *ChangeDataRequest_Register) XXX_DiscardUnknown() { xxx_messageInfo_ChangeDataRequest_Register.DiscardUnknown(m) } var xxx_messageInfo_ChangeDataRequest_Register proto.InternalMessageInfo type ChangeDataRequest_NotifyTxnStatus struct { TxnStatus []*TxnStatus `protobuf:"bytes,1,rep,name=txn_status,json=txnStatus" json:"txn_status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangeDataRequest_NotifyTxnStatus) Reset() { *m = ChangeDataRequest_NotifyTxnStatus{} } func (m *ChangeDataRequest_NotifyTxnStatus) String() string { return proto.CompactTextString(m) } func (*ChangeDataRequest_NotifyTxnStatus) ProtoMessage() {} func (*ChangeDataRequest_NotifyTxnStatus) Descriptor() ([]byte, []int) { return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{10, 1} } func (m *ChangeDataRequest_NotifyTxnStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangeDataRequest_NotifyTxnStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangeDataRequest_NotifyTxnStatus.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangeDataRequest_NotifyTxnStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangeDataRequest_NotifyTxnStatus.Merge(dst, src) } func (m *ChangeDataRequest_NotifyTxnStatus) XXX_Size() int { return m.Size() } func (m *ChangeDataRequest_NotifyTxnStatus) XXX_DiscardUnknown() { xxx_messageInfo_ChangeDataRequest_NotifyTxnStatus.DiscardUnknown(m) } var xxx_messageInfo_ChangeDataRequest_NotifyTxnStatus proto.InternalMessageInfo func (m *ChangeDataRequest_NotifyTxnStatus) GetTxnStatus() []*TxnStatus { if m != nil { return m.TxnStatus } return nil } func init() { proto.RegisterType((*Header)(nil), "cdcpb.Header") proto.RegisterType((*DuplicateRequest)(nil), "cdcpb.DuplicateRequest") proto.RegisterType((*Compatibility)(nil), "cdcpb.Compatibility") proto.RegisterType((*ClusterIDMismatch)(nil), "cdcpb.ClusterIDMismatch") proto.RegisterType((*Error)(nil), "cdcpb.Error") proto.RegisterType((*TxnInfo)(nil), "cdcpb.TxnInfo") proto.RegisterType((*TxnStatus)(nil), "cdcpb.TxnStatus") proto.RegisterType((*Event)(nil), "cdcpb.Event") proto.RegisterType((*Event_Row)(nil), "cdcpb.Event.Row") proto.RegisterType((*Event_Entries)(nil), "cdcpb.Event.Entries") proto.RegisterType((*Event_Admin)(nil), "cdcpb.Event.Admin") proto.RegisterType((*Event_LongTxn)(nil), "cdcpb.Event.LongTxn") proto.RegisterType((*ChangeDataEvent)(nil), "cdcpb.ChangeDataEvent") proto.RegisterType((*ResolvedTs)(nil), "cdcpb.ResolvedTs") proto.RegisterType((*ChangeDataRequest)(nil), "cdcpb.ChangeDataRequest") proto.RegisterType((*ChangeDataRequest_Register)(nil), "cdcpb.ChangeDataRequest.Register") proto.RegisterType((*ChangeDataRequest_NotifyTxnStatus)(nil), "cdcpb.ChangeDataRequest.NotifyTxnStatus") proto.RegisterEnum("cdcpb.Event_LogType", Event_LogType_name, Event_LogType_value) proto.RegisterEnum("cdcpb.Event_Row_OpType", Event_Row_OpType_name, Event_Row_OpType_value) proto.RegisterEnum("cdcpb.ChangeDataRequest_KvAPI", ChangeDataRequest_KvAPI_name, ChangeDataRequest_KvAPI_value) } // 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 // Client API for ChangeData service type ChangeDataClient interface { EventFeed(ctx context.Context, opts ...grpc.CallOption) (ChangeData_EventFeedClient, error) } type changeDataClient struct { cc *grpc.ClientConn } func NewChangeDataClient(cc *grpc.ClientConn) ChangeDataClient { return &changeDataClient{cc} } func (c *changeDataClient) EventFeed(ctx context.Context, opts ...grpc.CallOption) (ChangeData_EventFeedClient, error) { stream, err := c.cc.NewStream(ctx, &_ChangeData_serviceDesc.Streams[0], "/cdcpb.ChangeData/EventFeed", opts...) if err != nil { return nil, err } x := &changeDataEventFeedClient{stream} return x, nil } type ChangeData_EventFeedClient interface { Send(*ChangeDataRequest) error Recv() (*ChangeDataEvent, error) grpc.ClientStream } type changeDataEventFeedClient struct { grpc.ClientStream } func (x *changeDataEventFeedClient) Send(m *ChangeDataRequest) error { return x.ClientStream.SendMsg(m) } func (x *changeDataEventFeedClient) Recv() (*ChangeDataEvent, error) { m := new(ChangeDataEvent) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for ChangeData service type ChangeDataServer interface { EventFeed(ChangeData_EventFeedServer) error } func RegisterChangeDataServer(s *grpc.Server, srv ChangeDataServer) { s.RegisterService(&_ChangeData_serviceDesc, srv) } func _ChangeData_EventFeed_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ChangeDataServer).EventFeed(&changeDataEventFeedServer{stream}) } type ChangeData_EventFeedServer interface { Send(*ChangeDataEvent) error Recv() (*ChangeDataRequest, error) grpc.ServerStream } type changeDataEventFeedServer struct { grpc.ServerStream } func (x *changeDataEventFeedServer) Send(m *ChangeDataEvent) error { return x.ServerStream.SendMsg(m) } func (x *changeDataEventFeedServer) Recv() (*ChangeDataRequest, error) { m := new(ChangeDataRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } var _ChangeData_serviceDesc = grpc.ServiceDesc{ ServiceName: "cdcpb.ChangeData", HandlerType: (*ChangeDataServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "EventFeed", Handler: _ChangeData_EventFeed_Handler, ServerStreams: true, ClientStreams: true, }, }, Metadata: "cdcpb.proto", } func (m *Header) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Header) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.ClusterId)) } if len(m.TicdcVersion) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.TicdcVersion))) i += copy(dAtA[i:], m.TicdcVersion) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DuplicateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DuplicateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Compatibility) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Compatibility) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.RequiredVersion) > 0 { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.RequiredVersion))) i += copy(dAtA[i:], m.RequiredVersion) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ClusterIDMismatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ClusterIDMismatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Current != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Current)) } if m.Request != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Request)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.NotLeader != nil { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.NotLeader.Size())) n1, err := m.NotLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.RegionNotFound != nil { dAtA[i] = 0x12 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionNotFound.Size())) n2, err := m.RegionNotFound.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.EpochNotMatch != nil { dAtA[i] = 0x1a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.EpochNotMatch.Size())) n3, err := m.EpochNotMatch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.DuplicateRequest != nil { dAtA[i] = 0x22 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.DuplicateRequest.Size())) n4, err := m.DuplicateRequest.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.Compatibility != nil { dAtA[i] = 0x2a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Compatibility.Size())) n5, err := m.Compatibility.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.ClusterIdMismatch != nil { dAtA[i] = 0x32 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.ClusterIdMismatch.Size())) n6, err := m.ClusterIdMismatch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs)) } if len(m.Primary) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Primary))) i += copy(dAtA[i:], m.Primary) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnStatus) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs)) } if m.MinCommitTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.MinCommitTs)) } if m.CommitTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.CommitTs)) } if m.IsRolledBack { dAtA[i] = 0x20 i++ if m.IsRolledBack { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Event) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Event) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId)) } if m.Index != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Index)) } if m.Event != nil { nn7, err := m.Event.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn7 } if m.RequestId != 0 { dAtA[i] = 0x38 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RequestId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Event_Entries_) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Entries != nil { dAtA[i] = 0x1a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Entries.Size())) n8, err := m.Entries.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } return i, nil } func (m *Event_Admin_) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Admin != nil { dAtA[i] = 0x22 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Admin.Size())) n9, err := m.Admin.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } return i, nil } func (m *Event_Error) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Error != nil { dAtA[i] = 0x2a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Error.Size())) n10, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } return i, nil } func (m *Event_ResolvedTs) MarshalTo(dAtA []byte) (int, error) { i := 0 dAtA[i] = 0x30 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.ResolvedTs)) return i, nil } func (m *Event_LongTxn_) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.LongTxn != nil { dAtA[i] = 0x42 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.LongTxn.Size())) n11, err := m.LongTxn.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } return i, nil } func (m *Event_Row) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Event_Row) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs)) } if m.CommitTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.CommitTs)) } if m.Type != 0 { dAtA[i] = 0x18 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Type)) } if m.OpType != 0 { dAtA[i] = 0x20 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.OpType)) } if len(m.Key) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if len(m.OldValue) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.OldValue))) i += copy(dAtA[i:], m.OldValue) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Event_Entries) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Event_Entries) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Event_Admin) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Event_Admin) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.AdminRequest != nil { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.AdminRequest.Size())) n12, err := m.AdminRequest.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.AdminResponse != nil { dAtA[i] = 0x12 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.AdminResponse.Size())) n13, err := m.AdminResponse.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Event_LongTxn) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Event_LongTxn) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.TxnInfo) > 0 { for _, msg := range m.TxnInfo { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangeDataEvent) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangeDataEvent) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Events) > 0 { for _, msg := range m.Events { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.ResolvedTs != nil { dAtA[i] = 0x12 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.ResolvedTs.Size())) n14, err := m.ResolvedTs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResolvedTs) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolvedTs) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Regions) > 0 { dAtA16 := make([]byte, len(m.Regions)*10) var j15 int for _, num := range m.Regions { for num >= 1<<7 { dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j15++ } dAtA16[j15] = uint8(num) j15++ } dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(j15)) i += copy(dAtA[i:], dAtA16[:j15]) } if m.Ts != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Ts)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangeDataRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangeDataRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Header.Size())) n17, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId)) } if m.RegionEpoch != nil { dAtA[i] = 0x1a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionEpoch.Size())) n18, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.CheckpointTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.CheckpointTs)) } if len(m.StartKey) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintCdcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.RequestId != 0 { dAtA[i] = 0x38 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.RequestId)) } if m.ExtraOp != 0 { dAtA[i] = 0x40 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.ExtraOp)) } if m.Request != nil { nn19, err := m.Request.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn19 } if m.KvApi != 0 { dAtA[i] = 0x58 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.KvApi)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangeDataRequest_Register_) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Register != nil { dAtA[i] = 0x4a i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.Register.Size())) n20, err := m.Register.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } return i, nil } func (m *ChangeDataRequest_NotifyTxnStatus_) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.NotifyTxnStatus != nil { dAtA[i] = 0x52 i++ i = encodeVarintCdcpb(dAtA, i, uint64(m.NotifyTxnStatus.Size())) n21, err := m.NotifyTxnStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } return i, nil } func (m *ChangeDataRequest_Register) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangeDataRequest_Register) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangeDataRequest_NotifyTxnStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangeDataRequest_NotifyTxnStatus) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.TxnStatus) > 0 { for _, msg := range m.TxnStatus { dAtA[i] = 0xa i++ i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintCdcpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *Header) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovCdcpb(uint64(m.ClusterId)) } l = len(m.TicdcVersion) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DuplicateRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovCdcpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Compatibility) Size() (n int) { var l int _ = l l = len(m.RequiredVersion) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ClusterIDMismatch) Size() (n int) { var l int _ = l if m.Current != 0 { n += 1 + sovCdcpb(uint64(m.Current)) } if m.Request != 0 { n += 1 + sovCdcpb(uint64(m.Request)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l if m.NotLeader != nil { l = m.NotLeader.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.RegionNotFound != nil { l = m.RegionNotFound.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.EpochNotMatch != nil { l = m.EpochNotMatch.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.DuplicateRequest != nil { l = m.DuplicateRequest.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.Compatibility != nil { l = m.Compatibility.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.ClusterIdMismatch != nil { l = m.ClusterIdMismatch.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnInfo) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovCdcpb(uint64(m.StartTs)) } l = len(m.Primary) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnStatus) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovCdcpb(uint64(m.StartTs)) } if m.MinCommitTs != 0 { n += 1 + sovCdcpb(uint64(m.MinCommitTs)) } if m.CommitTs != 0 { n += 1 + sovCdcpb(uint64(m.CommitTs)) } if m.IsRolledBack { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Event) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovCdcpb(uint64(m.RegionId)) } if m.Index != 0 { n += 1 + sovCdcpb(uint64(m.Index)) } if m.Event != nil { n += m.Event.Size() } if m.RequestId != 0 { n += 1 + sovCdcpb(uint64(m.RequestId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Event_Entries_) Size() (n int) { var l int _ = l if m.Entries != nil { l = m.Entries.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *Event_Admin_) Size() (n int) { var l int _ = l if m.Admin != nil { l = m.Admin.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *Event_Error) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *Event_ResolvedTs) Size() (n int) { var l int _ = l n += 1 + sovCdcpb(uint64(m.ResolvedTs)) return n } func (m *Event_LongTxn_) Size() (n int) { var l int _ = l if m.LongTxn != nil { l = m.LongTxn.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *Event_Row) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovCdcpb(uint64(m.StartTs)) } if m.CommitTs != 0 { n += 1 + sovCdcpb(uint64(m.CommitTs)) } if m.Type != 0 { n += 1 + sovCdcpb(uint64(m.Type)) } if m.OpType != 0 { n += 1 + sovCdcpb(uint64(m.OpType)) } l = len(m.Key) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } l = len(m.OldValue) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Event_Entries) Size() (n int) { var l int _ = l if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovCdcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Event_Admin) Size() (n int) { var l int _ = l if m.AdminRequest != nil { l = m.AdminRequest.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.AdminResponse != nil { l = m.AdminResponse.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Event_LongTxn) Size() (n int) { var l int _ = l if len(m.TxnInfo) > 0 { for _, e := range m.TxnInfo { l = e.Size() n += 1 + l + sovCdcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangeDataEvent) Size() (n int) { var l int _ = l if len(m.Events) > 0 { for _, e := range m.Events { l = e.Size() n += 1 + l + sovCdcpb(uint64(l)) } } if m.ResolvedTs != nil { l = m.ResolvedTs.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResolvedTs) Size() (n int) { var l int _ = l if len(m.Regions) > 0 { l = 0 for _, e := range m.Regions { l += sovCdcpb(uint64(e)) } n += 1 + sovCdcpb(uint64(l)) + l } if m.Ts != 0 { n += 1 + sovCdcpb(uint64(m.Ts)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangeDataRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovCdcpb(uint64(m.RegionId)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovCdcpb(uint64(l)) } if m.CheckpointTs != 0 { n += 1 + sovCdcpb(uint64(m.CheckpointTs)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovCdcpb(uint64(l)) } if m.RequestId != 0 { n += 1 + sovCdcpb(uint64(m.RequestId)) } if m.ExtraOp != 0 { n += 1 + sovCdcpb(uint64(m.ExtraOp)) } if m.Request != nil { n += m.Request.Size() } if m.KvApi != 0 { n += 1 + sovCdcpb(uint64(m.KvApi)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangeDataRequest_Register_) Size() (n int) { var l int _ = l if m.Register != nil { l = m.Register.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *ChangeDataRequest_NotifyTxnStatus_) Size() (n int) { var l int _ = l if m.NotifyTxnStatus != nil { l = m.NotifyTxnStatus.Size() n += 1 + l + sovCdcpb(uint64(l)) } return n } func (m *ChangeDataRequest_Register) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangeDataRequest_NotifyTxnStatus) Size() (n int) { var l int _ = l if len(m.TxnStatus) > 0 { for _, e := range m.TxnStatus { l = e.Size() n += 1 + l + sovCdcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovCdcpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozCdcpb(x uint64) (n int) { return sovCdcpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *Header) 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 ErrIntOverflowCdcpb } 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: Header: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TicdcVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } 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 ErrInvalidLengthCdcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.TicdcVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *DuplicateRequest) 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 ErrIntOverflowCdcpb } 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: DuplicateRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DuplicateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Compatibility) 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 ErrIntOverflowCdcpb } 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: Compatibility: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Compatibility: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RequiredVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } 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 ErrInvalidLengthCdcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.RequiredVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ClusterIDMismatch) 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 ErrIntOverflowCdcpb } 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: ClusterIDMismatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ClusterIDMismatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) } m.Current = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Current |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } m.Request = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Request |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Error) 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 ErrIntOverflowCdcpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NotLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.NotLeader == nil { m.NotLeader = &errorpb.NotLeader{} } if err := m.NotLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionNotFound", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionNotFound == nil { m.RegionNotFound = &errorpb.RegionNotFound{} } if err := m.RegionNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EpochNotMatch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.EpochNotMatch == nil { m.EpochNotMatch = &errorpb.EpochNotMatch{} } if err := m.EpochNotMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DuplicateRequest", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DuplicateRequest == nil { m.DuplicateRequest = &DuplicateRequest{} } if err := m.DuplicateRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Compatibility", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Compatibility == nil { m.Compatibility = &Compatibility{} } if err := m.Compatibility.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdMismatch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ClusterIdMismatch == nil { m.ClusterIdMismatch = &ClusterIDMismatch{} } if err := m.ClusterIdMismatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *TxnInfo) 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 ErrIntOverflowCdcpb } 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: TxnInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Primary = append(m.Primary[:0], dAtA[iNdEx:postIndex]...) if m.Primary == nil { m.Primary = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *TxnStatus) 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 ErrIntOverflowCdcpb } 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: TxnStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRolledBack", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRolledBack = bool(v != 0) default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Event) 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 ErrIntOverflowCdcpb } 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: Event: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Event_Entries{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Event = &Event_Entries_{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Event_Admin{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Event = &Event_Admin_{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Error{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Event = &Event_Error{v} iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType) } var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Event = &Event_ResolvedTs{v} case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType) } m.RequestId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RequestId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LongTxn", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Event_LongTxn{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Event = &Event_LongTxn_{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Event_Row) 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 ErrIntOverflowCdcpb } 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: Row: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= (Event_LogType(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field OpType", wireType) } m.OpType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.OpType |= (Event_Row_OpType(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OldValue", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.OldValue = append(m.OldValue[:0], dAtA[iNdEx:postIndex]...) if m.OldValue == nil { m.OldValue = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Event_Entries) 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 ErrIntOverflowCdcpb } 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: Entries: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Entries: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &Event_Row{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Event_Admin) 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 ErrIntOverflowCdcpb } 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: Admin: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Admin: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AdminRequest", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminRequest == nil { m.AdminRequest = &raft_cmdpb.AdminRequest{} } if err := m.AdminRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AdminResponse", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminResponse == nil { m.AdminResponse = &raft_cmdpb.AdminResponse{} } if err := m.AdminResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *Event_LongTxn) 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 ErrIntOverflowCdcpb } 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: LongTxn: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LongTxn: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.TxnInfo = append(m.TxnInfo, &TxnInfo{}) if err := m.TxnInfo[len(m.TxnInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ChangeDataEvent) 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 ErrIntOverflowCdcpb } 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: ChangeDataEvent: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangeDataEvent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Events = append(m.Events, &Event{}) if err := m.Events[len(m.Events)-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 ResolvedTs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ResolvedTs == nil { m.ResolvedTs = &ResolvedTs{} } if err := m.ResolvedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ResolvedTs) 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 ErrIntOverflowCdcpb } 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: ResolvedTs: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolvedTs: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType) } m.Ts = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ts |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ChangeDataRequest) 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 ErrIntOverflowCdcpb } 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: ChangeDataRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangeDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType) } m.CheckpointTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CheckpointTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType) } m.RequestId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RequestId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExtraOp", wireType) } m.ExtraOp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExtraOp |= (kvrpcpb.ExtraOp(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Register", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &ChangeDataRequest_Register{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Request = &ChangeDataRequest_Register_{v} iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NotifyTxnStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &ChangeDataRequest_NotifyTxnStatus{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Request = &ChangeDataRequest_NotifyTxnStatus_{v} iNdEx = postIndex case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KvApi", wireType) } m.KvApi = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KvApi |= (ChangeDataRequest_KvAPI(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ChangeDataRequest_Register) 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 ErrIntOverflowCdcpb } 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: Register: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Register: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 *ChangeDataRequest_NotifyTxnStatus) 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 ErrIntOverflowCdcpb } 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: NotifyTxnStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NotifyTxnStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCdcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCdcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.TxnStatus = append(m.TxnStatus, &TxnStatus{}) if err := m.TxnStatus[len(m.TxnStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCdcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCdcpb } 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 skipCdcpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCdcpb } 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, ErrIntOverflowCdcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCdcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthCdcpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCdcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipCdcpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthCdcpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowCdcpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("cdcpb.proto", fileDescriptor_cdcpb_1c68e3d6625138c3) } var fileDescriptor_cdcpb_1c68e3d6625138c3 = []byte{ // 1354 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x56, 0xdd, 0x6e, 0xdb, 0xc6, 0x12, 0x16, 0xf5, 0x47, 0x69, 0x24, 0xd9, 0xf4, 0x26, 0x48, 0x14, 0x1d, 0x1c, 0x23, 0x87, 0x27, 0x39, 0xc7, 0x49, 0x01, 0x25, 0x71, 0x9b, 0x5c, 0x04, 0x68, 0x5a, 0xcb, 0x52, 0x6a, 0xc1, 0xb2, 0x1c, 0x6c, 0x19, 0x07, 0xe8, 0x45, 0x09, 0x9a, 0x5c, 0xcb, 0x84, 0x24, 0x2e, 0x43, 0xae, 0x14, 0xf9, 0x0d, 0xda, 0x00, 0xbd, 0xef, 0x0b, 0x14, 0xe8, 0xa3, 0xf4, 0xb2, 0x97, 0xbd, 0x2c, 0xd2, 0x17, 0x29, 0x76, 0x96, 0xa4, 0x7e, 0xf2, 0xd3, 0x2b, 0xee, 0xcc, 0x37, 0x3b, 0x3b, 0xff, 0x43, 0xa8, 0xb9, 0x9e, 0x1b, 0x9e, 0xb7, 0xc3, 0x88, 0x0b, 0x4e, 0x4a, 0x48, 0xb4, 0x8c, 0xc8, 0xb9, 0x10, 0xb6, 0x3b, 0xf5, 0x52, 0xa0, 0x55, 0x9f, 0x32, 0xe1, 0x64, 0x54, 0x83, 0x45, 0x11, 0x8f, 0x96, 0xe4, 0x78, 0x1e, 0x85, 0x99, 0x92, 0xd6, 0xf5, 0x11, 0x1f, 0x71, 0x3c, 0x3e, 0x90, 0xa7, 0x84, 0xbb, 0x1d, 0xcd, 0x62, 0x81, 0x47, 0xc5, 0x30, 0x07, 0x50, 0x3e, 0x62, 0x8e, 0xc7, 0x22, 0xf2, 0x6f, 0x00, 0x77, 0x32, 0x8b, 0x05, 0x8b, 0x6c, 0xdf, 0x6b, 0x6a, 0xb7, 0xb5, 0xbd, 0x22, 0xad, 0x26, 0x9c, 0xbe, 0x47, 0xfe, 0x0b, 0x0d, 0xe1, 0xbb, 0x9e, 0x6b, 0xcf, 0x59, 0x14, 0xfb, 0x3c, 0x68, 0xe6, 0x6f, 0x6b, 0x7b, 0x55, 0x5a, 0x47, 0xe6, 0x99, 0xe2, 0x99, 0x0f, 0xc0, 0xe8, 0xce, 0xc2, 0x89, 0xef, 0x3a, 0x82, 0x51, 0xf6, 0x7a, 0xc6, 0x62, 0x41, 0xfe, 0x05, 0xd5, 0x88, 0x8d, 0x7c, 0x1e, 0x2c, 0xd5, 0x56, 0x14, 0xa3, 0xef, 0x99, 0x4f, 0xa1, 0x71, 0xc8, 0xa7, 0xa1, 0x23, 0xfc, 0x73, 0x7f, 0xe2, 0x8b, 0x2b, 0x72, 0x0f, 0x8c, 0x88, 0xbd, 0x9e, 0xf9, 0x11, 0xf3, 0xb2, 0x97, 0x34, 0x7c, 0x69, 0x3b, 0xe5, 0xa7, 0x8f, 0x7d, 0x03, 0x3b, 0x87, 0x89, 0x79, 0xdd, 0x13, 0x3f, 0x9e, 0x3a, 0xc2, 0xbd, 0x24, 0x4d, 0xd0, 0xdd, 0x59, 0x14, 0xb1, 0x40, 0x24, 0x6f, 0xa5, 0xa4, 0x44, 0x22, 0x65, 0x12, 0x9a, 0x5e, 0xa4, 0x29, 0x69, 0xfe, 0x58, 0x80, 0x52, 0x4f, 0xc6, 0x92, 0x3c, 0x02, 0x08, 0xb8, 0xb0, 0x27, 0x18, 0x11, 0x54, 0x50, 0xdb, 0x27, 0xed, 0x34, 0xce, 0x43, 0x2e, 0x06, 0x88, 0xd0, 0x6a, 0x90, 0x1e, 0xc9, 0x81, 0x34, 0x18, 0xdd, 0x93, 0x37, 0x2f, 0xf8, 0x2c, 0xf0, 0x50, 0x7f, 0x6d, 0xff, 0x66, 0x76, 0x91, 0xa2, 0xc0, 0x90, 0x8b, 0xe7, 0x12, 0xa6, 0x5b, 0xd1, 0x1a, 0x4d, 0x9e, 0xc1, 0x36, 0x0b, 0xb9, 0x7b, 0x89, 0x1a, 0xd0, 0x8d, 0x66, 0x01, 0x35, 0xdc, 0xc8, 0x34, 0xf4, 0x24, 0x3e, 0xe4, 0xe2, 0x44, 0xa2, 0xb4, 0xc1, 0x56, 0x49, 0xd2, 0x85, 0x1d, 0x2f, 0x8d, 0xba, 0x9d, 0xfa, 0x58, 0x4c, 0x6c, 0x50, 0x85, 0xb5, 0x99, 0x15, 0x6a, 0x78, 0x9b, 0x79, 0x7a, 0x0a, 0x0d, 0x77, 0x35, 0x15, 0xcd, 0x12, 0x6a, 0xb8, 0x9e, 0x68, 0x58, 0x4b, 0x13, 0x5d, 0x17, 0x25, 0x47, 0x70, 0x6d, 0x59, 0x3b, 0xf6, 0x34, 0x49, 0x46, 0xb3, 0x8c, 0x1a, 0x9a, 0xa9, 0x86, 0xcd, 0x64, 0xd1, 0x9d, 0xac, 0xbc, 0x52, 0x96, 0xf9, 0x0c, 0x74, 0x6b, 0x11, 0xf4, 0x83, 0x0b, 0x4e, 0x6e, 0x41, 0x25, 0x16, 0x4e, 0x24, 0x6c, 0x11, 0xa7, 0xb9, 0x44, 0xda, 0x8a, 0x65, 0x2e, 0xc3, 0xc8, 0x9f, 0x3a, 0xd1, 0x15, 0xc6, 0xba, 0x4e, 0x53, 0xd2, 0xfc, 0x49, 0x83, 0xaa, 0xb5, 0x08, 0xbe, 0x15, 0x8e, 0x98, 0xc5, 0x9f, 0x52, 0x61, 0x42, 0x63, 0xea, 0x07, 0xb6, 0xcb, 0xa7, 0x53, 0x1f, 0x71, 0x55, 0x14, 0xb5, 0xa9, 0x1f, 0x1c, 0x22, 0xcf, 0x8a, 0x65, 0xe9, 0x2e, 0xf1, 0x82, 0x2a, 0x5d, 0x37, 0x05, 0xef, 0xc0, 0x96, 0x1f, 0xdb, 0x11, 0x9f, 0x4c, 0x98, 0x67, 0x9f, 0x3b, 0xee, 0x18, 0x43, 0x5e, 0xa1, 0x75, 0x3f, 0xa6, 0xc8, 0xec, 0x38, 0xee, 0xd8, 0xfc, 0x45, 0x87, 0x52, 0x6f, 0x2e, 0xeb, 0xef, 0x53, 0x7d, 0x40, 0xae, 0x43, 0xc9, 0x0f, 0x3c, 0xb6, 0x48, 0xac, 0x50, 0x04, 0x79, 0x08, 0x3a, 0x0b, 0x44, 0xe4, 0xb3, 0x38, 0x29, 0x88, 0x34, 0x19, 0xa8, 0xb1, 0xdd, 0x53, 0xd8, 0x51, 0x8e, 0xa6, 0x62, 0xe4, 0x3e, 0x94, 0x1c, 0x6f, 0xea, 0x07, 0x49, 0xfa, 0xc9, 0x9a, 0xfc, 0x81, 0x44, 0x8e, 0x72, 0x54, 0x89, 0x90, 0x3b, 0x50, 0xc2, 0xf2, 0x4a, 0x12, 0x5d, 0x4f, 0x65, 0x25, 0x4f, 0x4a, 0x21, 0x48, 0xee, 0x42, 0x2d, 0x62, 0x31, 0x9f, 0xcc, 0x99, 0x27, 0xa3, 0x20, 0x53, 0x5a, 0xec, 0xe4, 0x9b, 0xda, 0x51, 0x8e, 0x42, 0x0a, 0x58, 0xb1, 0x9c, 0x1e, 0x49, 0xe5, 0x49, 0xf7, 0x74, 0x35, 0x3d, 0x12, 0x4e, 0xdf, 0x23, 0x8f, 0xa0, 0x32, 0xe1, 0xc1, 0xc8, 0x16, 0x8b, 0xa0, 0x59, 0xf9, 0x80, 0x2b, 0x03, 0x1e, 0x8c, 0xac, 0x85, 0x34, 0x4e, 0x9f, 0xa8, 0x63, 0xeb, 0x6d, 0x1e, 0x0a, 0x94, 0xbf, 0xf9, 0x54, 0x0e, 0xd7, 0xf2, 0x93, 0xdf, 0xc8, 0xcf, 0x1e, 0x14, 0xc5, 0x55, 0xc8, 0x30, 0x72, 0x5b, 0xef, 0x3d, 0x37, 0xb2, 0xae, 0x42, 0x46, 0x51, 0x42, 0x86, 0x99, 0x87, 0x36, 0x0a, 0x17, 0x51, 0xf8, 0xe6, 0x9a, 0x30, 0xe5, 0x6f, 0xda, 0xa7, 0x21, 0xca, 0x97, 0x39, 0x7e, 0x89, 0x01, 0x85, 0x31, 0x53, 0x1d, 0x52, 0xa7, 0xf2, 0x28, 0x13, 0x38, 0x77, 0x26, 0x33, 0x86, 0x01, 0xaa, 0x53, 0x45, 0x48, 0x03, 0xf9, 0xc4, 0xb3, 0x15, 0xa2, 0x23, 0x52, 0xe1, 0x13, 0xef, 0x4c, 0xd2, 0xe6, 0x7d, 0x28, 0x2b, 0xb5, 0xa4, 0x06, 0xfa, 0xcb, 0xe1, 0xf1, 0xf0, 0xf4, 0xd5, 0xd0, 0xc8, 0x11, 0x1d, 0x0a, 0x2f, 0x5e, 0x5a, 0x86, 0x46, 0x00, 0xca, 0xdd, 0xde, 0xa0, 0x67, 0xf5, 0x8c, 0x7c, 0xeb, 0x31, 0xe8, 0xbd, 0x2c, 0xc5, 0x59, 0x51, 0x68, 0xb7, 0x0b, 0x7b, 0xb5, 0x7d, 0x63, 0xd3, 0xda, 0xac, 0x1c, 0x5a, 0x3f, 0x68, 0x50, 0xc2, 0xac, 0x93, 0x2f, 0xa1, 0x81, 0x59, 0xcf, 0xe6, 0x83, 0x96, 0xf4, 0xe6, 0xca, 0x92, 0x41, 0xc9, 0x74, 0x40, 0xd4, 0x9d, 0x15, 0x8a, 0x7c, 0x0d, 0x5b, 0xe9, 0xf5, 0x38, 0xe4, 0x41, 0xcc, 0x92, 0x19, 0x77, 0xeb, 0x03, 0xf7, 0x95, 0x00, 0x6d, 0x38, 0xab, 0x64, 0xeb, 0x0b, 0xd0, 0x93, 0x24, 0x93, 0x7b, 0x50, 0x11, 0x8b, 0xc0, 0xf6, 0x83, 0x0b, 0x9e, 0xb8, 0xb0, 0x95, 0xb8, 0x90, 0xb4, 0x3e, 0xd5, 0x85, 0x3a, 0x98, 0xdf, 0xcb, 0x5b, 0xa3, 0xf7, 0x83, 0x54, 0x87, 0xca, 0x0b, 0xda, 0x7b, 0x45, 0xfb, 0x56, 0x4f, 0x45, 0xea, 0xf0, 0xf4, 0xe4, 0xa4, 0x6f, 0x19, 0x79, 0x89, 0xd0, 0xd3, 0xc1, 0xa0, 0x73, 0x70, 0x78, 0x6c, 0x14, 0x48, 0x03, 0xaa, 0x0a, 0xb1, 0x7a, 0x5d, 0xa3, 0x48, 0xb6, 0xa1, 0xd6, 0x1f, 0xf6, 0xad, 0xfe, 0xc1, 0xa0, 0xff, 0x5d, 0xaf, 0x6b, 0x94, 0x3a, 0x3a, 0x94, 0x98, 0x0c, 0x9b, 0x39, 0x86, 0xed, 0xc3, 0x4b, 0x27, 0x18, 0xb1, 0xae, 0x23, 0x1c, 0xd5, 0xb0, 0x77, 0xa0, 0x8c, 0x58, 0x1a, 0xe7, 0xfa, 0x6a, 0x9c, 0x69, 0x82, 0x91, 0xfd, 0xf5, 0xfe, 0x50, 0x61, 0xd9, 0x49, 0x44, 0x69, 0xd6, 0x20, 0xab, 0xcd, 0x62, 0x3e, 0x01, 0x58, 0x22, 0x6a, 0x31, 0xc9, 0x39, 0xa0, 0x1e, 0xc2, 0xc5, 0x84, 0x24, 0xd9, 0x82, 0x7c, 0x56, 0xd8, 0x79, 0x11, 0x9b, 0x6f, 0x4b, 0xb0, 0xb3, 0xb4, 0x32, 0xcd, 0xcd, 0x5d, 0x28, 0x5f, 0xae, 0x2e, 0xac, 0x46, 0xf2, 0xb8, 0xda, 0xeb, 0x34, 0x01, 0xd7, 0xe7, 0x4f, 0x7e, 0x63, 0xfe, 0x3c, 0x81, 0x7a, 0x02, 0xe2, 0x6a, 0x49, 0xc6, 0xcd, 0xb5, 0x76, 0xf2, 0xc3, 0xa1, 0x16, 0x18, 0x2e, 0x21, 0x5a, 0x8b, 0x96, 0x84, 0xfc, 0x2b, 0x70, 0x2f, 0x99, 0x3b, 0x0e, 0xb9, 0x1f, 0x60, 0x17, 0x16, 0x51, 0x71, 0x7d, 0xc9, 0x54, 0x6d, 0xaa, 0x3a, 0x78, 0xd9, 0x33, 0xaa, 0xa5, 0x8f, 0xd9, 0x15, 0xb9, 0x29, 0xcb, 0xd9, 0x43, 0x48, 0xb5, 0x4e, 0x99, 0x05, 0x9e, 0x04, 0xfe, 0x61, 0xa2, 0x7c, 0x06, 0x15, 0xb6, 0x10, 0x91, 0x63, 0xf3, 0x10, 0x27, 0xca, 0xd6, 0xbe, 0xd1, 0x4e, 0xff, 0x80, 0x7a, 0x12, 0x38, 0x0d, 0xa9, 0xce, 0xd4, 0x81, 0x7c, 0x05, 0xe8, 0xaa, 0xdc, 0x35, 0xcd, 0x2a, 0xba, 0xf6, 0x9f, 0x74, 0x29, 0x6d, 0x86, 0x13, 0x7d, 0x95, 0x82, 0x47, 0x39, 0x9a, 0x5d, 0x22, 0x67, 0xb0, 0x13, 0x70, 0xe1, 0x5f, 0x5c, 0xc9, 0x09, 0x66, 0xc7, 0xb8, 0x5d, 0x9a, 0x80, 0x9a, 0xf6, 0x3e, 0xaa, 0x69, 0x88, 0x37, 0xb2, 0x6d, 0x74, 0x94, 0xa3, 0xdb, 0xc1, 0x3a, 0x8b, 0x3c, 0x86, 0xf2, 0x78, 0x6e, 0x3b, 0xa1, 0xdf, 0xac, 0xa1, 0x0f, 0xbb, 0x1f, 0x55, 0x76, 0x3c, 0x3f, 0x78, 0xd1, 0xa7, 0xa5, 0xf1, 0xfc, 0x20, 0xf4, 0x5b, 0x00, 0x95, 0xd4, 0xcc, 0x56, 0x07, 0xb6, 0x37, 0x1e, 0x22, 0x0f, 0x00, 0x56, 0xcc, 0x5c, 0x9f, 0x12, 0x99, 0x14, 0xad, 0x8a, 0xf4, 0x68, 0xfe, 0x1f, 0x4a, 0xa8, 0x9f, 0x54, 0xa0, 0x68, 0xf9, 0x9d, 0xae, 0x91, 0x23, 0x55, 0x28, 0x51, 0xe7, 0xcd, 0xf1, 0x99, 0xa1, 0xc9, 0xa3, 0xb5, 0x08, 0x8e, 0xcf, 0x8c, 0x7c, 0xa7, 0x9a, 0xfd, 0x44, 0xed, 0x9f, 0x02, 0x2c, 0xad, 0x24, 0x07, 0x50, 0xc5, 0xbe, 0x78, 0xce, 0x98, 0x47, 0x9a, 0x1f, 0xf3, 0xa2, 0x75, 0xe3, 0x3d, 0x04, 0x6f, 0xed, 0x69, 0x0f, 0xb5, 0xce, 0xff, 0xfe, 0xf8, 0xb5, 0xa2, 0xfd, 0xf6, 0x6e, 0x57, 0xfb, 0xfd, 0xdd, 0xae, 0xf6, 0xe7, 0xbb, 0x5d, 0xed, 0xe7, 0xbf, 0x76, 0x73, 0x60, 0xf0, 0x68, 0xd4, 0x16, 0xfe, 0x78, 0xde, 0x1e, 0xcf, 0xf1, 0x97, 0xf5, 0xbc, 0x8c, 0x9f, 0xcf, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x9f, 0xc4, 0x8e, 0x72, 0x34, 0x0b, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/configpb/000077500000000000000000000000001421456440000166555ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/configpb/configpb.pb.go000066400000000000000000003677111421456440000214120ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: configpb.proto package configpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" _ "google.golang.org/genproto/googleapis/api/annotations" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type StatusCode int32 const ( StatusCode_UNKNOWN StatusCode = 0 StatusCode_OK StatusCode = 1 StatusCode_WRONG_VERSION StatusCode = 2 StatusCode_NOT_CHANGE StatusCode = 3 StatusCode_COMPONENT_NOT_FOUND StatusCode = 4 StatusCode_COMPONENT_ID_NOT_FOUND StatusCode = 5 ) var StatusCode_name = map[int32]string{ 0: "UNKNOWN", 1: "OK", 2: "WRONG_VERSION", 3: "NOT_CHANGE", 4: "COMPONENT_NOT_FOUND", 5: "COMPONENT_ID_NOT_FOUND", } var StatusCode_value = map[string]int32{ "UNKNOWN": 0, "OK": 1, "WRONG_VERSION": 2, "NOT_CHANGE": 3, "COMPONENT_NOT_FOUND": 4, "COMPONENT_ID_NOT_FOUND": 5, } func (x StatusCode) String() string { return proto.EnumName(StatusCode_name, int32(x)) } func (StatusCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{0} } type Status struct { Code StatusCode `protobuf:"varint,1,opt,name=code,proto3,enum=configpb.StatusCode" json:"code,omitempty"` Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Status) Reset() { *m = Status{} } func (m *Status) String() string { return proto.CompactTextString(m) } func (*Status) ProtoMessage() {} func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{0} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Status) XXX_Merge(src proto.Message) { xxx_messageInfo_Status.Merge(dst, 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 func (m *Status) GetCode() StatusCode { if m != nil { return m.Code } return StatusCode_UNKNOWN } func (m *Status) GetMessage() string { if m != nil { return m.Message } return "" } // The version is used to tell the configuration which can be shared // or not apart. // Global version represents the version of these configuration // which can be shared, each kind of component only have one. // For local version, every component will have one to represent // the version of these configuration which cannot be shared. type Version struct { Local uint64 `protobuf:"varint,1,opt,name=local,proto3" json:"local,omitempty"` Global uint64 `protobuf:"varint,2,opt,name=global,proto3" json:"global,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Version) Reset() { *m = Version{} } func (m *Version) String() string { return proto.CompactTextString(m) } func (*Version) ProtoMessage() {} func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{1} } func (m *Version) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Version.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Version) XXX_Merge(src proto.Message) { xxx_messageInfo_Version.Merge(dst, src) } func (m *Version) XXX_Size() int { return m.Size() } func (m *Version) XXX_DiscardUnknown() { xxx_messageInfo_Version.DiscardUnknown(m) } var xxx_messageInfo_Version proto.InternalMessageInfo func (m *Version) GetLocal() uint64 { if m != nil { return m.Local } return 0 } func (m *Version) GetGlobal() uint64 { if m != nil { return m.Global } return 0 } type Local struct { ComponentId string `protobuf:"bytes,1,opt,name=component_id,json=componentId,proto3" json:"component_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Local) Reset() { *m = Local{} } func (m *Local) String() string { return proto.CompactTextString(m) } func (*Local) ProtoMessage() {} func (*Local) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{2} } func (m *Local) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Local) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Local.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Local) XXX_Merge(src proto.Message) { xxx_messageInfo_Local.Merge(dst, src) } func (m *Local) XXX_Size() int { return m.Size() } func (m *Local) XXX_DiscardUnknown() { xxx_messageInfo_Local.DiscardUnknown(m) } var xxx_messageInfo_Local proto.InternalMessageInfo func (m *Local) GetComponentId() string { if m != nil { return m.ComponentId } return "" } type Global struct { Component string `protobuf:"bytes,1,opt,name=component,proto3" json:"component,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Global) Reset() { *m = Global{} } func (m *Global) String() string { return proto.CompactTextString(m) } func (*Global) ProtoMessage() {} func (*Global) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{3} } func (m *Global) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Global) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Global.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Global) XXX_Merge(src proto.Message) { xxx_messageInfo_Global.Merge(dst, src) } func (m *Global) XXX_Size() int { return m.Size() } func (m *Global) XXX_DiscardUnknown() { xxx_messageInfo_Global.DiscardUnknown(m) } var xxx_messageInfo_Global proto.InternalMessageInfo func (m *Global) GetComponent() string { if m != nil { return m.Component } return "" } type ConfigKind struct { // Types that are valid to be assigned to Kind: // *ConfigKind_Local // *ConfigKind_Global Kind isConfigKind_Kind `protobuf_oneof:"kind"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfigKind) Reset() { *m = ConfigKind{} } func (m *ConfigKind) String() string { return proto.CompactTextString(m) } func (*ConfigKind) ProtoMessage() {} func (*ConfigKind) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{4} } func (m *ConfigKind) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfigKind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfigKind.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfigKind) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfigKind.Merge(dst, src) } func (m *ConfigKind) XXX_Size() int { return m.Size() } func (m *ConfigKind) XXX_DiscardUnknown() { xxx_messageInfo_ConfigKind.DiscardUnknown(m) } var xxx_messageInfo_ConfigKind proto.InternalMessageInfo type isConfigKind_Kind interface { isConfigKind_Kind() MarshalTo([]byte) (int, error) Size() int } type ConfigKind_Local struct { Local *Local `protobuf:"bytes,1,opt,name=local,oneof"` } type ConfigKind_Global struct { Global *Global `protobuf:"bytes,2,opt,name=global,oneof"` } func (*ConfigKind_Local) isConfigKind_Kind() {} func (*ConfigKind_Global) isConfigKind_Kind() {} func (m *ConfigKind) GetKind() isConfigKind_Kind { if m != nil { return m.Kind } return nil } func (m *ConfigKind) GetLocal() *Local { if x, ok := m.GetKind().(*ConfigKind_Local); ok { return x.Local } return nil } func (m *ConfigKind) GetGlobal() *Global { if x, ok := m.GetKind().(*ConfigKind_Global); ok { return x.Global } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*ConfigKind) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _ConfigKind_OneofMarshaler, _ConfigKind_OneofUnmarshaler, _ConfigKind_OneofSizer, []interface{}{ (*ConfigKind_Local)(nil), (*ConfigKind_Global)(nil), } } func _ConfigKind_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*ConfigKind) // kind switch x := m.Kind.(type) { case *ConfigKind_Local: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Local); err != nil { return err } case *ConfigKind_Global: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Global); err != nil { return err } case nil: default: return fmt.Errorf("ConfigKind.Kind has unexpected type %T", x) } return nil } func _ConfigKind_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*ConfigKind) switch tag { case 1: // kind.local if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Local) err := b.DecodeMessage(msg) m.Kind = &ConfigKind_Local{msg} return true, err case 2: // kind.global if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Global) err := b.DecodeMessage(msg) m.Kind = &ConfigKind_Global{msg} return true, err default: return false, nil } } func _ConfigKind_OneofSizer(msg proto.Message) (n int) { m := msg.(*ConfigKind) // kind switch x := m.Kind.(type) { case *ConfigKind_Local: s := proto.Size(x.Local) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *ConfigKind_Global: s := proto.Size(x.Global) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type ConfigEntry struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfigEntry) Reset() { *m = ConfigEntry{} } func (m *ConfigEntry) String() string { return proto.CompactTextString(m) } func (*ConfigEntry) ProtoMessage() {} func (*ConfigEntry) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{5} } func (m *ConfigEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfigEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfigEntry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfigEntry) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfigEntry.Merge(dst, src) } func (m *ConfigEntry) XXX_Size() int { return m.Size() } func (m *ConfigEntry) XXX_DiscardUnknown() { xxx_messageInfo_ConfigEntry.DiscardUnknown(m) } var xxx_messageInfo_ConfigEntry proto.InternalMessageInfo func (m *ConfigEntry) GetName() string { if m != nil { return m.Name } return "" } func (m *ConfigEntry) GetValue() string { if m != nil { return m.Value } return "" } type LocalConfig struct { Version *Version `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"` Component string `protobuf:"bytes,2,opt,name=component,proto3" json:"component,omitempty"` ComponentId string `protobuf:"bytes,3,opt,name=component_id,json=componentId,proto3" json:"component_id,omitempty"` Config string `protobuf:"bytes,4,opt,name=config,proto3" json:"config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LocalConfig) Reset() { *m = LocalConfig{} } func (m *LocalConfig) String() string { return proto.CompactTextString(m) } func (*LocalConfig) ProtoMessage() {} func (*LocalConfig) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{6} } func (m *LocalConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LocalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LocalConfig.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LocalConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_LocalConfig.Merge(dst, src) } func (m *LocalConfig) XXX_Size() int { return m.Size() } func (m *LocalConfig) XXX_DiscardUnknown() { xxx_messageInfo_LocalConfig.DiscardUnknown(m) } var xxx_messageInfo_LocalConfig proto.InternalMessageInfo func (m *LocalConfig) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *LocalConfig) GetComponent() string { if m != nil { return m.Component } return "" } func (m *LocalConfig) GetComponentId() string { if m != nil { return m.ComponentId } return "" } func (m *LocalConfig) GetConfig() string { if m != nil { return m.Config } return "" } type Header struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{7} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Header.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Header) XXX_Merge(src proto.Message) { xxx_messageInfo_Header.Merge(dst, src) } func (m *Header) XXX_Size() int { return m.Size() } func (m *Header) XXX_DiscardUnknown() { xxx_messageInfo_Header.DiscardUnknown(m) } var xxx_messageInfo_Header proto.InternalMessageInfo func (m *Header) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } type CreateRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Version *Version `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` Component string `protobuf:"bytes,3,opt,name=component,proto3" json:"component,omitempty"` ComponentId string `protobuf:"bytes,4,opt,name=component_id,json=componentId,proto3" json:"component_id,omitempty"` Config string `protobuf:"bytes,5,opt,name=config,proto3" json:"config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateRequest) Reset() { *m = CreateRequest{} } func (m *CreateRequest) String() string { return proto.CompactTextString(m) } func (*CreateRequest) ProtoMessage() {} func (*CreateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{8} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CreateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateRequest.Merge(dst, 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 func (m *CreateRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *CreateRequest) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *CreateRequest) GetComponent() string { if m != nil { return m.Component } return "" } func (m *CreateRequest) GetComponentId() string { if m != nil { return m.ComponentId } return "" } func (m *CreateRequest) GetConfig() string { if m != nil { return m.Config } return "" } type CreateResponse struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Status *Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` Version *Version `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"` Config string `protobuf:"bytes,4,opt,name=config,proto3" json:"config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateResponse) Reset() { *m = CreateResponse{} } func (m *CreateResponse) String() string { return proto.CompactTextString(m) } func (*CreateResponse) ProtoMessage() {} func (*CreateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{9} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CreateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateResponse.Merge(dst, 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 func (m *CreateResponse) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *CreateResponse) GetStatus() *Status { if m != nil { return m.Status } return nil } func (m *CreateResponse) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *CreateResponse) GetConfig() string { if m != nil { return m.Config } return "" } type GetAllRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllRequest) Reset() { *m = GetAllRequest{} } func (m *GetAllRequest) String() string { return proto.CompactTextString(m) } func (*GetAllRequest) ProtoMessage() {} func (*GetAllRequest) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{10} } func (m *GetAllRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllRequest.Merge(dst, src) } func (m *GetAllRequest) XXX_Size() int { return m.Size() } func (m *GetAllRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetAllRequest.DiscardUnknown(m) } var xxx_messageInfo_GetAllRequest proto.InternalMessageInfo func (m *GetAllRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } type GetAllResponse struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Status *Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` LocalConfigs []*LocalConfig `protobuf:"bytes,3,rep,name=local_configs,json=localConfigs" json:"local_configs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllResponse) Reset() { *m = GetAllResponse{} } func (m *GetAllResponse) String() string { return proto.CompactTextString(m) } func (*GetAllResponse) ProtoMessage() {} func (*GetAllResponse) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{11} } func (m *GetAllResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllResponse.Merge(dst, src) } func (m *GetAllResponse) XXX_Size() int { return m.Size() } func (m *GetAllResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetAllResponse.DiscardUnknown(m) } var xxx_messageInfo_GetAllResponse proto.InternalMessageInfo func (m *GetAllResponse) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *GetAllResponse) GetStatus() *Status { if m != nil { return m.Status } return nil } func (m *GetAllResponse) GetLocalConfigs() []*LocalConfig { if m != nil { return m.LocalConfigs } return nil } type GetRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Version *Version `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` Component string `protobuf:"bytes,3,opt,name=component,proto3" json:"component,omitempty"` ComponentId string `protobuf:"bytes,4,opt,name=component_id,json=componentId,proto3" json:"component_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{12} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRequest.Merge(dst, 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 func (m *GetRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *GetRequest) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *GetRequest) GetComponent() string { if m != nil { return m.Component } return "" } func (m *GetRequest) GetComponentId() string { if m != nil { return m.ComponentId } return "" } type GetResponse struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Status *Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` Version *Version `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"` Config string `protobuf:"bytes,4,opt,name=config,proto3" json:"config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{13} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetResponse.Merge(dst, 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 func (m *GetResponse) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *GetResponse) GetStatus() *Status { if m != nil { return m.Status } return nil } func (m *GetResponse) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *GetResponse) GetConfig() string { if m != nil { return m.Config } return "" } type UpdateRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Version *Version `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` Kind *ConfigKind `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"` Entries []*ConfigEntry `protobuf:"bytes,4,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateRequest) Reset() { *m = UpdateRequest{} } func (m *UpdateRequest) String() string { return proto.CompactTextString(m) } func (*UpdateRequest) ProtoMessage() {} func (*UpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{14} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateRequest.Merge(dst, 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 func (m *UpdateRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *UpdateRequest) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *UpdateRequest) GetKind() *ConfigKind { if m != nil { return m.Kind } return nil } func (m *UpdateRequest) GetEntries() []*ConfigEntry { if m != nil { return m.Entries } return nil } type UpdateResponse struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Status *Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` Version *Version `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"` Config string `protobuf:"bytes,4,opt,name=config,proto3" json:"config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateResponse) Reset() { *m = UpdateResponse{} } func (m *UpdateResponse) String() string { return proto.CompactTextString(m) } func (*UpdateResponse) ProtoMessage() {} func (*UpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{15} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateResponse.Merge(dst, 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 func (m *UpdateResponse) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *UpdateResponse) GetStatus() *Status { if m != nil { return m.Status } return nil } func (m *UpdateResponse) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *UpdateResponse) GetConfig() string { if m != nil { return m.Config } return "" } type DeleteRequest struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Version *Version `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` Kind *ConfigKind `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRequest) ProtoMessage() {} func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{16} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRequest.Merge(dst, 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 func (m *DeleteRequest) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *DeleteRequest) GetVersion() *Version { if m != nil { return m.Version } return nil } func (m *DeleteRequest) GetKind() *ConfigKind { if m != nil { return m.Kind } return nil } type DeleteResponse struct { Header *Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Status *Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` Version *Version `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } func (*DeleteResponse) ProtoMessage() {} func (*DeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_configpb_6d0f7689747bcf7d, []int{17} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteResponse.Merge(dst, 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 func (m *DeleteResponse) GetHeader() *Header { if m != nil { return m.Header } return nil } func (m *DeleteResponse) GetStatus() *Status { if m != nil { return m.Status } return nil } func (m *DeleteResponse) GetVersion() *Version { if m != nil { return m.Version } return nil } func init() { proto.RegisterType((*Status)(nil), "configpb.Status") proto.RegisterType((*Version)(nil), "configpb.Version") proto.RegisterType((*Local)(nil), "configpb.Local") proto.RegisterType((*Global)(nil), "configpb.Global") proto.RegisterType((*ConfigKind)(nil), "configpb.ConfigKind") proto.RegisterType((*ConfigEntry)(nil), "configpb.ConfigEntry") proto.RegisterType((*LocalConfig)(nil), "configpb.LocalConfig") proto.RegisterType((*Header)(nil), "configpb.Header") proto.RegisterType((*CreateRequest)(nil), "configpb.CreateRequest") proto.RegisterType((*CreateResponse)(nil), "configpb.CreateResponse") proto.RegisterType((*GetAllRequest)(nil), "configpb.GetAllRequest") proto.RegisterType((*GetAllResponse)(nil), "configpb.GetAllResponse") proto.RegisterType((*GetRequest)(nil), "configpb.GetRequest") proto.RegisterType((*GetResponse)(nil), "configpb.GetResponse") proto.RegisterType((*UpdateRequest)(nil), "configpb.UpdateRequest") proto.RegisterType((*UpdateResponse)(nil), "configpb.UpdateResponse") proto.RegisterType((*DeleteRequest)(nil), "configpb.DeleteRequest") proto.RegisterType((*DeleteResponse)(nil), "configpb.DeleteResponse") proto.RegisterEnum("configpb.StatusCode", StatusCode_name, StatusCode_value) } // 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 // Client API for Config service type ConfigClient interface { Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) GetAll(ctx context.Context, in *GetAllRequest, opts ...grpc.CallOption) (*GetAllResponse, error) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) } type configClient struct { cc *grpc.ClientConn } func NewConfigClient(cc *grpc.ClientConn) ConfigClient { return &configClient{cc} } func (c *configClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) { out := new(CreateResponse) err := c.cc.Invoke(ctx, "/configpb.Config/Create", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *configClient) GetAll(ctx context.Context, in *GetAllRequest, opts ...grpc.CallOption) (*GetAllResponse, error) { out := new(GetAllResponse) err := c.cc.Invoke(ctx, "/configpb.Config/GetAll", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *configClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { out := new(GetResponse) err := c.cc.Invoke(ctx, "/configpb.Config/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *configClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) { out := new(UpdateResponse) err := c.cc.Invoke(ctx, "/configpb.Config/Update", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *configClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { out := new(DeleteResponse) err := c.cc.Invoke(ctx, "/configpb.Config/Delete", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for Config service type ConfigServer interface { Create(context.Context, *CreateRequest) (*CreateResponse, error) GetAll(context.Context, *GetAllRequest) (*GetAllResponse, error) Get(context.Context, *GetRequest) (*GetResponse, error) Update(context.Context, *UpdateRequest) (*UpdateResponse, error) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) } func RegisterConfigServer(s *grpc.Server, srv ConfigServer) { s.RegisterService(&_Config_serviceDesc, srv) } func _Config_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.(ConfigServer).Create(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/configpb.Config/Create", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ConfigServer).Create(ctx, req.(*CreateRequest)) } return interceptor(ctx, in, info, handler) } func _Config_GetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetAllRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ConfigServer).GetAll(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/configpb.Config/GetAll", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ConfigServer).GetAll(ctx, req.(*GetAllRequest)) } return interceptor(ctx, in, info, handler) } func _Config_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.(ConfigServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/configpb.Config/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ConfigServer).Get(ctx, req.(*GetRequest)) } return interceptor(ctx, in, info, handler) } func _Config_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.(ConfigServer).Update(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/configpb.Config/Update", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ConfigServer).Update(ctx, req.(*UpdateRequest)) } return interceptor(ctx, in, info, handler) } func _Config_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.(ConfigServer).Delete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/configpb.Config/Delete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ConfigServer).Delete(ctx, req.(*DeleteRequest)) } return interceptor(ctx, in, info, handler) } var _Config_serviceDesc = grpc.ServiceDesc{ ServiceName: "configpb.Config", HandlerType: (*ConfigServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Create", Handler: _Config_Create_Handler, }, { MethodName: "GetAll", Handler: _Config_GetAll_Handler, }, { MethodName: "Get", Handler: _Config_Get_Handler, }, { MethodName: "Update", Handler: _Config_Update_Handler, }, { MethodName: "Delete", Handler: _Config_Delete_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "configpb.proto", } func (m *Status) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Status) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Code != 0 { dAtA[i] = 0x8 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Code)) } if len(m.Message) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Version) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Version) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Local != 0 { dAtA[i] = 0x8 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Local)) } if m.Global != 0 { dAtA[i] = 0x10 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Global)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Local) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Local) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ComponentId) > 0 { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.ComponentId))) i += copy(dAtA[i:], m.ComponentId) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Global) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Global) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Component) > 0 { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Component))) i += copy(dAtA[i:], m.Component) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfigKind) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfigKind) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Kind != nil { nn1, err := m.Kind.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfigKind_Local) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Local != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Local.Size())) n2, err := m.Local.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } return i, nil } func (m *ConfigKind_Global) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Global != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Global.Size())) n3, err := m.Global.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } return i, nil } func (m *ConfigEntry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfigEntry) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LocalConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LocalConfig) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Version != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n4, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if len(m.Component) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Component))) i += copy(dAtA[i:], m.Component) } if len(m.ComponentId) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.ComponentId))) i += copy(dAtA[i:], m.ComponentId) } if len(m.Config) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Config))) i += copy(dAtA[i:], m.Config) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Header) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Header) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.ClusterId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CreateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n5, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.Version != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n6, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if len(m.Component) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Component))) i += copy(dAtA[i:], m.Component) } if len(m.ComponentId) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.ComponentId))) i += copy(dAtA[i:], m.ComponentId) } if len(m.Config) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Config))) i += copy(dAtA[i:], m.Config) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CreateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CreateResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n7, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.Status != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Status.Size())) n8, err := m.Status.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.Version != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n9, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if len(m.Config) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Config))) i += copy(dAtA[i:], m.Config) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n10, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n11, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if m.Status != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Status.Size())) n12, err := m.Status.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if len(m.LocalConfigs) > 0 { for _, msg := range m.LocalConfigs { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n13, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.Version != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n14, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if len(m.Component) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Component))) i += copy(dAtA[i:], m.Component) } if len(m.ComponentId) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.ComponentId))) i += copy(dAtA[i:], m.ComponentId) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n15, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.Status != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Status.Size())) n16, err := m.Status.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if m.Version != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n17, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if len(m.Config) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Config))) i += copy(dAtA[i:], m.Config) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n18, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.Version != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n19, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if m.Kind != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Kind.Size())) n20, err := m.Kind.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n21, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } if m.Status != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Status.Size())) n22, err := m.Status.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } if m.Version != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n23, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 } if len(m.Config) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintConfigpb(dAtA, i, uint64(len(m.Config))) i += copy(dAtA[i:], m.Config) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n24, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n24 } if m.Version != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n25, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } if m.Kind != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Kind.Size())) n26, err := m.Kind.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Header.Size())) n27, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } if m.Status != nil { dAtA[i] = 0x12 i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Status.Size())) n28, err := m.Status.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n28 } if m.Version != nil { dAtA[i] = 0x1a i++ i = encodeVarintConfigpb(dAtA, i, uint64(m.Version.Size())) n29, err := m.Version.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n29 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintConfigpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *Status) Size() (n int) { var l int _ = l if m.Code != 0 { n += 1 + sovConfigpb(uint64(m.Code)) } l = len(m.Message) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Version) Size() (n int) { var l int _ = l if m.Local != 0 { n += 1 + sovConfigpb(uint64(m.Local)) } if m.Global != 0 { n += 1 + sovConfigpb(uint64(m.Global)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Local) Size() (n int) { var l int _ = l l = len(m.ComponentId) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Global) Size() (n int) { var l int _ = l l = len(m.Component) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfigKind) Size() (n int) { var l int _ = l if m.Kind != nil { n += m.Kind.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfigKind_Local) Size() (n int) { var l int _ = l if m.Local != nil { l = m.Local.Size() n += 1 + l + sovConfigpb(uint64(l)) } return n } func (m *ConfigKind_Global) Size() (n int) { var l int _ = l if m.Global != nil { l = m.Global.Size() n += 1 + l + sovConfigpb(uint64(l)) } return n } func (m *ConfigEntry) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LocalConfig) Size() (n int) { var l int _ = l if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Component) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.ComponentId) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Header) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovConfigpb(uint64(m.ClusterId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Component) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.ComponentId) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CreateResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Status != nil { l = m.Status.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Status != nil { l = m.Status.Size() n += 1 + l + sovConfigpb(uint64(l)) } if len(m.LocalConfigs) > 0 { for _, e := range m.LocalConfigs { l = e.Size() n += 1 + l + sovConfigpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Component) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.ComponentId) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Status != nil { l = m.Status.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Kind != nil { l = m.Kind.Size() n += 1 + l + sovConfigpb(uint64(l)) } if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovConfigpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Status != nil { l = m.Status.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } l = len(m.Config) if l > 0 { n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Kind != nil { l = m.Kind.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Status != nil { l = m.Status.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.Version != nil { l = m.Version.Size() n += 1 + l + sovConfigpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovConfigpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozConfigpb(x uint64) (n int) { return sovConfigpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } 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 ErrIntOverflowConfigpb } 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 != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) } m.Code = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Code |= (StatusCode(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *Version) 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 ErrIntOverflowConfigpb } 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: Version: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) } m.Local = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Local |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Global", wireType) } m.Global = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Global |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *Local) 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 ErrIntOverflowConfigpb } 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: Local: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Local: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ComponentId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ComponentId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *Global) 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 ErrIntOverflowConfigpb } 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: Global: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Global: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Component = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *ConfigKind) 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 ErrIntOverflowConfigpb } 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: ConfigKind: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfigKind: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Local{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Kind = &ConfigKind_Local{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Global", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Global{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Kind = &ConfigKind_Global{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *ConfigEntry) 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 ErrIntOverflowConfigpb } 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: ConfigEntry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfigEntry: 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 ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *LocalConfig) 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 ErrIntOverflowConfigpb } 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: LocalConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LocalConfig: 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 msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Component = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ComponentId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ComponentId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Config = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *Header) 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 ErrIntOverflowConfigpb } 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: Header: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Component = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ComponentId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ComponentId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Config = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen 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 case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Config = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *GetAllRequest) 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 ErrIntOverflowConfigpb } 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: GetAllRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 *GetAllResponse) 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 ErrIntOverflowConfigpb } 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: GetAllResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen 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 case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LocalConfigs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.LocalConfigs = append(m.LocalConfigs, &LocalConfig{}) if err := m.LocalConfigs[len(m.LocalConfigs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Component = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ComponentId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ComponentId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen 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 case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Config = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Kind == nil { m.Kind = &ConfigKind{} } if err := m.Kind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &ConfigEntry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen 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 case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } 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 ErrInvalidLengthConfigpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Config = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Kind == nil { m.Kind = &ConfigKind{} } if err := m.Kind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 ErrIntOverflowConfigpb } 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 Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &Header{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen 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 case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowConfigpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthConfigpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Version == nil { m.Version = &Version{} } if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipConfigpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthConfigpb } 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 skipConfigpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowConfigpb } 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, ErrIntOverflowConfigpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowConfigpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthConfigpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowConfigpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipConfigpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthConfigpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowConfigpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("configpb.proto", fileDescriptor_configpb_6d0f7689747bcf7d) } var fileDescriptor_configpb_6d0f7689747bcf7d = []byte{ // 830 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4f, 0x6f, 0xe3, 0x44, 0x14, 0xcf, 0x24, 0x8e, 0xb3, 0x79, 0x6e, 0xd2, 0xec, 0x90, 0xee, 0x46, 0xd1, 0x12, 0x95, 0x39, 0xb0, 0x51, 0x90, 0x36, 0x52, 0x38, 0xac, 0x58, 0x89, 0xc3, 0x36, 0x4d, 0x93, 0xa8, 0xc5, 0x46, 0xd3, 0x7f, 0xc7, 0xc8, 0x8d, 0x87, 0x60, 0xe1, 0x7a, 0x82, 0xed, 0x54, 0xea, 0x95, 0x4f, 0x00, 0xea, 0x85, 0x23, 0x07, 0x84, 0xe0, 0x53, 0x20, 0x6e, 0x1c, 0x91, 0xb8, 0x70, 0x44, 0x85, 0x6f, 0xc0, 0x17, 0x40, 0x99, 0xb1, 0xeb, 0x71, 0x22, 0xa8, 0x7a, 0xa8, 0x94, 0x9b, 0xdf, 0xbc, 0x3f, 0xf3, 0xfb, 0xfd, 0xfc, 0xde, 0xb3, 0xa1, 0x3a, 0xe5, 0xfe, 0x67, 0xee, 0x6c, 0x7e, 0xf1, 0x6a, 0x1e, 0xf0, 0x88, 0xe3, 0x27, 0x89, 0xdd, 0xac, 0xcf, 0xf8, 0x8c, 0x8b, 0xc3, 0xee, 0xf2, 0x49, 0xfa, 0x9b, 0xdb, 0xc1, 0x22, 0x8c, 0xc4, 0x63, 0x7c, 0xf0, 0x62, 0xc6, 0xf9, 0xcc, 0x63, 0x5d, 0x7b, 0xee, 0x76, 0x6d, 0xdf, 0xe7, 0x91, 0x1d, 0xb9, 0xdc, 0x0f, 0xa5, 0x97, 0x1c, 0x81, 0x7e, 0x1c, 0xd9, 0xd1, 0x22, 0xc4, 0x6d, 0xd0, 0xa6, 0xdc, 0x61, 0x0d, 0xb4, 0x8b, 0xda, 0xd5, 0x5e, 0xfd, 0xd5, 0xdd, 0xbd, 0xd2, 0xdf, 0xe7, 0x0e, 0xa3, 0x22, 0x02, 0x37, 0xa0, 0x74, 0xc9, 0xc2, 0xd0, 0x9e, 0xb1, 0x46, 0x7e, 0x17, 0xb5, 0xcb, 0x34, 0x31, 0xc9, 0x6b, 0x28, 0x9d, 0xb1, 0x20, 0x74, 0xb9, 0x8f, 0xeb, 0x50, 0xf4, 0xf8, 0xd4, 0xf6, 0x44, 0x3d, 0x8d, 0x4a, 0x03, 0x3f, 0x03, 0x7d, 0xe6, 0xf1, 0x0b, 0xdb, 0x13, 0x99, 0x1a, 0x8d, 0x2d, 0xd2, 0x81, 0xe2, 0x91, 0x08, 0x78, 0x0f, 0xb6, 0xa6, 0xfc, 0x72, 0xce, 0x7d, 0xe6, 0x47, 0x13, 0xd7, 0x11, 0xd9, 0x65, 0x6a, 0xdc, 0x9d, 0x8d, 0x1d, 0xf2, 0x3e, 0xe8, 0x43, 0x91, 0x85, 0x5f, 0x40, 0xf9, 0xce, 0x11, 0x47, 0xa6, 0x07, 0xc4, 0x05, 0xe8, 0x0b, 0x0e, 0x87, 0xae, 0xef, 0xe0, 0x97, 0x2a, 0x1e, 0xa3, 0xb7, 0x9d, 0xf2, 0x13, 0x17, 0x8f, 0x72, 0x09, 0xc4, 0x4e, 0x06, 0xa2, 0xd1, 0xab, 0xa5, 0x91, 0xf2, 0xda, 0x51, 0x2e, 0x81, 0xbd, 0xa7, 0x83, 0xf6, 0x85, 0xeb, 0x3b, 0xe4, 0x35, 0x18, 0xf2, 0xaa, 0x81, 0x1f, 0x05, 0xd7, 0x18, 0x83, 0xe6, 0xdb, 0x97, 0x2c, 0x86, 0x24, 0x9e, 0x97, 0x7a, 0x5c, 0xd9, 0xde, 0x22, 0x91, 0x4c, 0x1a, 0xe4, 0x06, 0x81, 0x21, 0xee, 0x97, 0xe9, 0xf8, 0x03, 0x28, 0x5d, 0x49, 0x01, 0x63, 0x9c, 0x4f, 0xd3, 0xdb, 0x63, 0x65, 0x69, 0x12, 0x91, 0xa5, 0x9f, 0x5f, 0xa1, 0xbf, 0xa6, 0x64, 0x61, 0x4d, 0xc9, 0xe5, 0xdb, 0x90, 0xd5, 0x1b, 0x9a, 0x70, 0xc6, 0x16, 0x79, 0x09, 0xfa, 0x88, 0xd9, 0x0e, 0x0b, 0xf0, 0xbb, 0x00, 0x53, 0x6f, 0x11, 0x46, 0x2c, 0x48, 0x5e, 0x86, 0x46, 0xcb, 0xf1, 0xc9, 0xd8, 0x21, 0x3f, 0x23, 0xa8, 0xf4, 0x03, 0x66, 0x47, 0x8c, 0xb2, 0x2f, 0x17, 0x2c, 0x8c, 0x70, 0x1b, 0xf4, 0xcf, 0x45, 0x6a, 0x8c, 0x5f, 0x51, 0x4f, 0x96, 0xa4, 0xb1, 0x5f, 0xa5, 0x9a, 0x7f, 0x18, 0xd5, 0xc2, 0x7d, 0x54, 0xb5, 0xff, 0xa3, 0x5a, 0xcc, 0x50, 0xfd, 0x09, 0x41, 0x35, 0x61, 0x10, 0xce, 0xb9, 0x1f, 0xb2, 0x07, 0x50, 0x68, 0x83, 0x1e, 0x8a, 0xe1, 0x58, 0x6f, 0x15, 0x39, 0x34, 0x34, 0xf6, 0xab, 0x64, 0x0b, 0xf7, 0x92, 0xfd, 0xaf, 0xd7, 0xf2, 0x11, 0x54, 0x86, 0x2c, 0x7a, 0xeb, 0x79, 0x0f, 0x16, 0x9b, 0x7c, 0x87, 0xa0, 0x9a, 0xe4, 0x3e, 0x22, 0xcd, 0x37, 0x50, 0x11, 0x43, 0x34, 0x91, 0x01, 0x61, 0xa3, 0xb0, 0x5b, 0x68, 0x1b, 0xbd, 0x9d, 0x95, 0x61, 0x93, 0xcd, 0x4e, 0xb7, 0xbc, 0xd4, 0x08, 0xc9, 0xf7, 0x08, 0x60, 0xc8, 0xa2, 0x0d, 0x6f, 0x24, 0xf2, 0x03, 0x02, 0x43, 0xc0, 0xdc, 0xf4, 0x6e, 0xf9, 0x05, 0x41, 0xe5, 0x74, 0xee, 0x3c, 0xfe, 0x6c, 0xb6, 0xe5, 0x12, 0x8c, 0xa1, 0x2a, 0x1f, 0x8e, 0x74, 0xfb, 0x52, 0x11, 0x81, 0xbb, 0x50, 0x62, 0x7e, 0x14, 0xb8, 0x2c, 0x6c, 0x68, 0xab, 0x8d, 0xa1, 0xec, 0x4f, 0x9a, 0x44, 0x89, 0xe9, 0x4c, 0x38, 0x6c, 0xba, 0xde, 0x5f, 0x23, 0xa8, 0xec, 0x33, 0x8f, 0x6d, 0x8e, 0xde, 0xe4, 0x1b, 0x04, 0xd5, 0x04, 0xd2, 0x86, 0xc8, 0xd7, 0xb9, 0x06, 0x48, 0x7f, 0x28, 0xb0, 0x01, 0xa5, 0x53, 0xf3, 0xd0, 0xb4, 0xce, 0xcd, 0x5a, 0x0e, 0xeb, 0x90, 0xb7, 0x0e, 0x6b, 0x08, 0x3f, 0x85, 0xca, 0x39, 0xb5, 0xcc, 0xe1, 0xe4, 0x6c, 0x40, 0x8f, 0xc7, 0x96, 0x59, 0xcb, 0xe3, 0x2a, 0x80, 0x69, 0x9d, 0x4c, 0xfa, 0xa3, 0xb7, 0xe6, 0x70, 0x50, 0x2b, 0xe0, 0xe7, 0xf0, 0x4e, 0xdf, 0xfa, 0xe4, 0x53, 0xcb, 0x1c, 0x98, 0x27, 0x93, 0xa5, 0xe7, 0xc0, 0x3a, 0x35, 0xf7, 0x6b, 0x1a, 0x6e, 0xc2, 0xb3, 0xd4, 0x31, 0xde, 0x57, 0x7c, 0xc5, 0xde, 0x3f, 0x79, 0xd0, 0xe3, 0xef, 0xec, 0xc7, 0xa0, 0xcb, 0xad, 0x8f, 0x9f, 0x2b, 0xfa, 0xa9, 0x5f, 0xb2, 0x66, 0x63, 0xdd, 0x21, 0x35, 0x24, 0xb9, 0x65, 0xba, 0xdc, 0xa6, 0x6a, 0x7a, 0x66, 0x37, 0xab, 0xe9, 0xd9, 0xc5, 0x4b, 0x72, 0xf8, 0x00, 0x0a, 0x43, 0x16, 0xe1, 0x7a, 0x26, 0x24, 0x49, 0xdc, 0x59, 0x39, 0x8d, 0xb3, 0xf0, 0x57, 0xbf, 0xff, 0x7d, 0x93, 0xdf, 0xc2, 0xd0, 0x4d, 0xd7, 0x15, 0x05, 0x5d, 0x4e, 0x87, 0x0a, 0x23, 0x33, 0xf3, 0x2a, 0x8c, 0xec, 0x20, 0x91, 0x1d, 0x51, 0x70, 0x9b, 0x28, 0x05, 0xdf, 0xa0, 0x0e, 0xb6, 0x40, 0x97, 0x2d, 0xa3, 0xd6, 0xcc, 0xf4, 0xb5, 0x5a, 0x33, 0xdb, 0x5d, 0x09, 0xc8, 0x8e, 0x52, 0x73, 0xaf, 0xfe, 0xc7, 0x8f, 0x4f, 0xd0, 0xaf, 0xb7, 0x2d, 0xf4, 0xdb, 0x6d, 0x0b, 0xfd, 0x79, 0xdb, 0x42, 0xdf, 0xfe, 0xd5, 0xca, 0x5d, 0xe8, 0xe2, 0xf7, 0xf3, 0xc3, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xbe, 0x62, 0x2c, 0x39, 0xdf, 0x0a, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/configpb/configpb.pb.gw.go000066400000000000000000000274101421456440000220130ustar00rootroot00000000000000// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. // source: configpb.proto /* Package configpb is a reverse proxy. It translates gRPC into RESTful JSON APIs. */ package configpb import ( "context" "io" "net/http" "github.com/golang/protobuf/descriptor" "github.com/golang/protobuf/proto" "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/grpc-ecosystem/grpc-gateway/utilities" "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/grpclog" "google.golang.org/grpc/status" ) // Suppress "imported and not used" errors var _ codes.Code var _ io.Reader var _ status.Status var _ = runtime.String var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage var ( filter_Config_Get_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) func request_Config_Get_0(ctx context.Context, marshaler runtime.Marshaler, client ConfigClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq GetRequest var metadata runtime.ServerMetadata if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Config_Get_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := client.Get(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } func local_request_Config_Get_0(ctx context.Context, marshaler runtime.Marshaler, server ConfigServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq GetRequest var metadata runtime.ServerMetadata if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Config_Get_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := server.Get(ctx, &protoReq) return msg, metadata, err } func request_Config_Update_0(ctx context.Context, marshaler runtime.Marshaler, client ConfigClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq UpdateRequest var metadata runtime.ServerMetadata newReader, berr := utilities.IOReaderFactory(req.Body) if berr != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) } if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := client.Update(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } func local_request_Config_Update_0(ctx context.Context, marshaler runtime.Marshaler, server ConfigServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq UpdateRequest var metadata runtime.ServerMetadata newReader, berr := utilities.IOReaderFactory(req.Body) if berr != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) } if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := server.Update(ctx, &protoReq) return msg, metadata, err } var ( filter_Config_Delete_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) func request_Config_Delete_0(ctx context.Context, marshaler runtime.Marshaler, client ConfigClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq DeleteRequest var metadata runtime.ServerMetadata if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Config_Delete_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } func local_request_Config_Delete_0(ctx context.Context, marshaler runtime.Marshaler, server ConfigServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq DeleteRequest var metadata runtime.ServerMetadata if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Config_Delete_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } msg, err := server.Delete(ctx, &protoReq) return msg, metadata, err } // RegisterConfigHandlerServer registers the http handlers for service Config to "mux". // UnaryRPC :call ConfigServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. func RegisterConfigHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ConfigServer) error { mux.Handle("GET", pattern_Config_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := local_request_Config_Get_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Get_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) mux.Handle("POST", pattern_Config_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := local_request_Config_Update_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Update_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) mux.Handle("DELETE", pattern_Config_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := local_request_Config_Delete_0(rctx, inboundMarshaler, server, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Delete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) return nil } // RegisterConfigHandlerFromEndpoint is same as RegisterConfigHandler but // automatically dials to "endpoint" and closes the connection when "ctx" gets done. func RegisterConfigHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { conn, err := grpc.Dial(endpoint, opts...) if err != nil { return err } defer func() { if err != nil { if cerr := conn.Close(); cerr != nil { grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) } return } go func() { <-ctx.Done() if cerr := conn.Close(); cerr != nil { grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) } }() }() return RegisterConfigHandler(ctx, mux, conn) } // RegisterConfigHandler registers the http handlers for service Config to "mux". // The handlers forward requests to the grpc endpoint over "conn". func RegisterConfigHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { return RegisterConfigHandlerClient(ctx, mux, NewConfigClient(conn)) } // RegisterConfigHandlerClient registers the http handlers for service Config // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ConfigClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ConfigClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in // "ConfigClient" to call the correct interceptors. func RegisterConfigHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ConfigClient) error { mux.Handle("GET", pattern_Config_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := request_Config_Get_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Get_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) mux.Handle("POST", pattern_Config_Update_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := request_Config_Update_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Update_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) mux.Handle("DELETE", pattern_Config_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) rctx, err := runtime.AnnotateContext(ctx, mux, req) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } resp, md, err := request_Config_Delete_0(rctx, inboundMarshaler, client, req, pathParams) ctx = runtime.NewServerMetadataContext(ctx, md) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } forward_Config_Delete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) return nil } var ( pattern_Config_Get_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"component"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Config_Update_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"component"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Config_Delete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"component"}, "", runtime.AssumeColonVerbOpt(true))) ) var ( forward_Config_Get_0 = runtime.ForwardResponseMessage forward_Config_Update_0 = runtime.ForwardResponseMessage forward_Config_Delete_0 = runtime.ForwardResponseMessage ) kvproto-6.1.0-alpha/pkg/coprocessor/000077500000000000000000000000001421456440000174275ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/coprocessor/coprocessor.pb.go000066400000000000000000002134001421456440000227170ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: coprocessor.proto package coprocessor import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" metapb "github.com/pingcap/kvproto/pkg/metapb" github_com_pingcap_kvproto_pkg_sharedbytes "github.com/pingcap/kvproto/pkg/sharedbytes" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // [start, end) type KeyRange struct { Start []byte `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyRange) Reset() { *m = KeyRange{} } func (m *KeyRange) String() string { return proto.CompactTextString(m) } func (*KeyRange) ProtoMessage() {} func (*KeyRange) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{0} } func (m *KeyRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyRange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyRange) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyRange.Merge(dst, src) } func (m *KeyRange) XXX_Size() int { return m.Size() } func (m *KeyRange) XXX_DiscardUnknown() { xxx_messageInfo_KeyRange.DiscardUnknown(m) } var xxx_messageInfo_KeyRange proto.InternalMessageInfo func (m *KeyRange) GetStart() []byte { if m != nil { return m.Start } return nil } func (m *KeyRange) GetEnd() []byte { if m != nil { return m.End } return nil } type Request struct { Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Tp int64 `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"` Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` StartTs uint64 `protobuf:"varint,7,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Ranges []*KeyRange `protobuf:"bytes,4,rep,name=ranges" json:"ranges,omitempty"` // If cache is enabled, TiKV returns cache hit instead of data if // its last version matches this `cache_if_match_version`. IsCacheEnabled bool `protobuf:"varint,5,opt,name=is_cache_enabled,json=isCacheEnabled,proto3" json:"is_cache_enabled,omitempty"` CacheIfMatchVersion uint64 `protobuf:"varint,6,opt,name=cache_if_match_version,json=cacheIfMatchVersion,proto3" json:"cache_if_match_version,omitempty"` // Any schema-ful storage to validate schema correctness if necessary. SchemaVer int64 `protobuf:"varint,8,opt,name=schema_ver,json=schemaVer,proto3" json:"schema_ver,omitempty"` IsTraceEnabled bool `protobuf:"varint,9,opt,name=is_trace_enabled,json=isTraceEnabled,proto3" json:"is_trace_enabled,omitempty"` // paging_size is 0 when it's disabled, otherwise, it should be a positive number. PagingSize uint64 `protobuf:"varint,10,opt,name=paging_size,json=pagingSize,proto3" json:"paging_size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Request) Reset() { *m = Request{} } func (m *Request) String() string { return proto.CompactTextString(m) } func (*Request) ProtoMessage() {} func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{1} } func (m *Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Request) XXX_Merge(src proto.Message) { xxx_messageInfo_Request.Merge(dst, src) } func (m *Request) XXX_Size() int { return m.Size() } func (m *Request) XXX_DiscardUnknown() { xxx_messageInfo_Request.DiscardUnknown(m) } var xxx_messageInfo_Request proto.InternalMessageInfo func (m *Request) GetContext() *kvrpcpb.Context { if m != nil { return m.Context } return nil } func (m *Request) GetTp() int64 { if m != nil { return m.Tp } return 0 } func (m *Request) GetData() []byte { if m != nil { return m.Data } return nil } func (m *Request) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *Request) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } func (m *Request) GetIsCacheEnabled() bool { if m != nil { return m.IsCacheEnabled } return false } func (m *Request) GetCacheIfMatchVersion() uint64 { if m != nil { return m.CacheIfMatchVersion } return 0 } func (m *Request) GetSchemaVer() int64 { if m != nil { return m.SchemaVer } return 0 } func (m *Request) GetIsTraceEnabled() bool { if m != nil { return m.IsTraceEnabled } return false } func (m *Request) GetPagingSize() uint64 { if m != nil { return m.PagingSize } return 0 } type Response struct { Data github_com_pingcap_kvproto_pkg_sharedbytes.SharedBytes `protobuf:"bytes,1,opt,name=data,proto3,customtype=github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes" json:"data"` RegionError *errorpb.Error `protobuf:"bytes,2,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Locked *kvrpcpb.LockInfo `protobuf:"bytes,3,opt,name=locked" json:"locked,omitempty"` OtherError string `protobuf:"bytes,4,opt,name=other_error,json=otherError,proto3" json:"other_error,omitempty"` Range *KeyRange `protobuf:"bytes,5,opt,name=range" json:"range,omitempty"` // This field is always filled for compatibility consideration. However // newer TiDB should respect `exec_details_v2` field instead. ExecDetails *kvrpcpb.ExecDetails `protobuf:"bytes,6,opt,name=exec_details,json=execDetails" json:"exec_details,omitempty"` // This field is provided in later versions, containing more detailed // information. ExecDetailsV2 *kvrpcpb.ExecDetailsV2 `protobuf:"bytes,11,opt,name=exec_details_v2,json=execDetailsV2" json:"exec_details_v2,omitempty"` IsCacheHit bool `protobuf:"varint,7,opt,name=is_cache_hit,json=isCacheHit,proto3" json:"is_cache_hit,omitempty"` CacheLastVersion uint64 `protobuf:"varint,8,opt,name=cache_last_version,json=cacheLastVersion,proto3" json:"cache_last_version,omitempty"` CanBeCached bool `protobuf:"varint,9,opt,name=can_be_cached,json=canBeCached,proto3" json:"can_be_cached,omitempty"` // Contains the latest buckets version of the region. // Clients should query PD to update buckets in cache if its is stale. LatestBucketsVersion uint64 `protobuf:"varint,12,opt,name=latest_buckets_version,json=latestBucketsVersion,proto3" json:"latest_buckets_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{2} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Response) XXX_Merge(src proto.Message) { xxx_messageInfo_Response.Merge(dst, src) } func (m *Response) XXX_Size() int { return m.Size() } func (m *Response) XXX_DiscardUnknown() { xxx_messageInfo_Response.DiscardUnknown(m) } var xxx_messageInfo_Response proto.InternalMessageInfo func (m *Response) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *Response) GetLocked() *kvrpcpb.LockInfo { if m != nil { return m.Locked } return nil } func (m *Response) GetOtherError() string { if m != nil { return m.OtherError } return "" } func (m *Response) GetRange() *KeyRange { if m != nil { return m.Range } return nil } func (m *Response) GetExecDetails() *kvrpcpb.ExecDetails { if m != nil { return m.ExecDetails } return nil } func (m *Response) GetExecDetailsV2() *kvrpcpb.ExecDetailsV2 { if m != nil { return m.ExecDetailsV2 } return nil } func (m *Response) GetIsCacheHit() bool { if m != nil { return m.IsCacheHit } return false } func (m *Response) GetCacheLastVersion() uint64 { if m != nil { return m.CacheLastVersion } return 0 } func (m *Response) GetCanBeCached() bool { if m != nil { return m.CanBeCached } return false } func (m *Response) GetLatestBucketsVersion() uint64 { if m != nil { return m.LatestBucketsVersion } return 0 } type RegionInfo struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` Ranges []*KeyRange `protobuf:"bytes,3,rep,name=ranges" json:"ranges,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionInfo) Reset() { *m = RegionInfo{} } func (m *RegionInfo) String() string { return proto.CompactTextString(m) } func (*RegionInfo) ProtoMessage() {} func (*RegionInfo) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{3} } func (m *RegionInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionInfo.Merge(dst, src) } func (m *RegionInfo) XXX_Size() int { return m.Size() } func (m *RegionInfo) XXX_DiscardUnknown() { xxx_messageInfo_RegionInfo.DiscardUnknown(m) } var xxx_messageInfo_RegionInfo proto.InternalMessageInfo func (m *RegionInfo) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RegionInfo) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *RegionInfo) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } type TableRegions struct { PhysicalTableId int64 `protobuf:"varint,1,opt,name=physical_table_id,json=physicalTableId,proto3" json:"physical_table_id,omitempty"` Regions []*RegionInfo `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TableRegions) Reset() { *m = TableRegions{} } func (m *TableRegions) String() string { return proto.CompactTextString(m) } func (*TableRegions) ProtoMessage() {} func (*TableRegions) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{4} } func (m *TableRegions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TableRegions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TableRegions.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TableRegions) XXX_Merge(src proto.Message) { xxx_messageInfo_TableRegions.Merge(dst, src) } func (m *TableRegions) XXX_Size() int { return m.Size() } func (m *TableRegions) XXX_DiscardUnknown() { xxx_messageInfo_TableRegions.DiscardUnknown(m) } var xxx_messageInfo_TableRegions proto.InternalMessageInfo func (m *TableRegions) GetPhysicalTableId() int64 { if m != nil { return m.PhysicalTableId } return 0 } func (m *TableRegions) GetRegions() []*RegionInfo { if m != nil { return m.Regions } return nil } type BatchRequest struct { Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Tp int64 `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"` Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` Regions []*RegionInfo `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"` StartTs uint64 `protobuf:"varint,5,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` // Any schema-ful storage to validate schema correctness if necessary. SchemaVer int64 `protobuf:"varint,6,opt,name=schema_ver,json=schemaVer,proto3" json:"schema_ver,omitempty"` // Used for partition table scan TableRegions []*TableRegions `protobuf:"bytes,7,rep,name=table_regions,json=tableRegions" json:"table_regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchRequest) Reset() { *m = BatchRequest{} } func (m *BatchRequest) String() string { return proto.CompactTextString(m) } func (*BatchRequest) ProtoMessage() {} func (*BatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{5} } func (m *BatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchRequest.Merge(dst, src) } func (m *BatchRequest) XXX_Size() int { return m.Size() } func (m *BatchRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchRequest proto.InternalMessageInfo func (m *BatchRequest) GetContext() *kvrpcpb.Context { if m != nil { return m.Context } return nil } func (m *BatchRequest) GetTp() int64 { if m != nil { return m.Tp } return 0 } func (m *BatchRequest) GetData() []byte { if m != nil { return m.Data } return nil } func (m *BatchRequest) GetRegions() []*RegionInfo { if m != nil { return m.Regions } return nil } func (m *BatchRequest) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *BatchRequest) GetSchemaVer() int64 { if m != nil { return m.SchemaVer } return 0 } func (m *BatchRequest) GetTableRegions() []*TableRegions { if m != nil { return m.TableRegions } return nil } type BatchResponse struct { Data github_com_pingcap_kvproto_pkg_sharedbytes.SharedBytes `protobuf:"bytes,1,opt,name=data,proto3,customtype=github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes" json:"data"` OtherError string `protobuf:"bytes,2,opt,name=other_error,json=otherError,proto3" json:"other_error,omitempty"` ExecDetails *kvrpcpb.ExecDetails `protobuf:"bytes,3,opt,name=exec_details,json=execDetails" json:"exec_details,omitempty"` RetryRegions []*metapb.Region `protobuf:"bytes,4,rep,name=retry_regions,json=retryRegions" json:"retry_regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchResponse) Reset() { *m = BatchResponse{} } func (m *BatchResponse) String() string { return proto.CompactTextString(m) } func (*BatchResponse) ProtoMessage() {} func (*BatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor_coprocessor_590779721bad773d, []int{6} } func (m *BatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchResponse.Merge(dst, src) } func (m *BatchResponse) XXX_Size() int { return m.Size() } func (m *BatchResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchResponse proto.InternalMessageInfo func (m *BatchResponse) GetOtherError() string { if m != nil { return m.OtherError } return "" } func (m *BatchResponse) GetExecDetails() *kvrpcpb.ExecDetails { if m != nil { return m.ExecDetails } return nil } func (m *BatchResponse) GetRetryRegions() []*metapb.Region { if m != nil { return m.RetryRegions } return nil } func init() { proto.RegisterType((*KeyRange)(nil), "coprocessor.KeyRange") proto.RegisterType((*Request)(nil), "coprocessor.Request") proto.RegisterType((*Response)(nil), "coprocessor.Response") proto.RegisterType((*RegionInfo)(nil), "coprocessor.RegionInfo") proto.RegisterType((*TableRegions)(nil), "coprocessor.TableRegions") proto.RegisterType((*BatchRequest)(nil), "coprocessor.BatchRequest") proto.RegisterType((*BatchResponse)(nil), "coprocessor.BatchResponse") } func (m *KeyRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyRange) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Start) > 0 { dAtA[i] = 0xa i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.Start))) i += copy(dAtA[i:], m.Start) } if len(m.End) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.End))) i += copy(dAtA[i:], m.End) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Request) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Request) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Context.Size())) n1, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.Tp != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Tp)) } if len(m.Data) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x22 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.IsCacheEnabled { dAtA[i] = 0x28 i++ if m.IsCacheEnabled { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.CacheIfMatchVersion != 0 { dAtA[i] = 0x30 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.CacheIfMatchVersion)) } if m.StartTs != 0 { dAtA[i] = 0x38 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.StartTs)) } if m.SchemaVer != 0 { dAtA[i] = 0x40 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.SchemaVer)) } if m.IsTraceEnabled { dAtA[i] = 0x48 i++ if m.IsTraceEnabled { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.PagingSize != 0 { dAtA[i] = 0x50 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.PagingSize)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Response) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Response) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0xa i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Data.Size())) n2, err := m.Data.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 if m.RegionError != nil { dAtA[i] = 0x12 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.RegionError.Size())) n3, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.Locked != nil { dAtA[i] = 0x1a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Locked.Size())) n4, err := m.Locked.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if len(m.OtherError) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.OtherError))) i += copy(dAtA[i:], m.OtherError) } if m.Range != nil { dAtA[i] = 0x2a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Range.Size())) n5, err := m.Range.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.ExecDetails != nil { dAtA[i] = 0x32 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.ExecDetails.Size())) n6, err := m.ExecDetails.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.IsCacheHit { dAtA[i] = 0x38 i++ if m.IsCacheHit { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.CacheLastVersion != 0 { dAtA[i] = 0x40 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.CacheLastVersion)) } if m.CanBeCached { dAtA[i] = 0x48 i++ if m.CanBeCached { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ExecDetailsV2 != nil { dAtA[i] = 0x5a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.ExecDetailsV2.Size())) n7, err := m.ExecDetailsV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.LatestBucketsVersion != 0 { dAtA[i] = 0x60 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.LatestBucketsVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.RegionId)) } if m.RegionEpoch != nil { dAtA[i] = 0x12 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.RegionEpoch.Size())) n8, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x1a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TableRegions) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TableRegions) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.PhysicalTableId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.PhysicalTableId)) } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x12 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Context.Size())) n9, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.Tp != 0 { dAtA[i] = 0x10 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Tp)) } if len(m.Data) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x22 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.StartTs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.StartTs)) } if m.SchemaVer != 0 { dAtA[i] = 0x30 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.SchemaVer)) } if len(m.TableRegions) > 0 { for _, msg := range m.TableRegions { dAtA[i] = 0x3a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0xa i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.Data.Size())) n10, err := m.Data.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 if len(m.OtherError) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.OtherError))) i += copy(dAtA[i:], m.OtherError) } if m.ExecDetails != nil { dAtA[i] = 0x1a i++ i = encodeVarintCoprocessor(dAtA, i, uint64(m.ExecDetails.Size())) n11, err := m.ExecDetails.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if len(m.RetryRegions) > 0 { for _, msg := range m.RetryRegions { dAtA[i] = 0x22 i++ i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintCoprocessor(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *KeyRange) Size() (n int) { var l int _ = l l = len(m.Start) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } l = len(m.End) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Request) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.Tp != 0 { n += 1 + sovCoprocessor(uint64(m.Tp)) } l = len(m.Data) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.IsCacheEnabled { n += 2 } if m.CacheIfMatchVersion != 0 { n += 1 + sovCoprocessor(uint64(m.CacheIfMatchVersion)) } if m.StartTs != 0 { n += 1 + sovCoprocessor(uint64(m.StartTs)) } if m.SchemaVer != 0 { n += 1 + sovCoprocessor(uint64(m.SchemaVer)) } if m.IsTraceEnabled { n += 2 } if m.PagingSize != 0 { n += 1 + sovCoprocessor(uint64(m.PagingSize)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Response) Size() (n int) { var l int _ = l l = m.Data.Size() n += 1 + l + sovCoprocessor(uint64(l)) if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.Locked != nil { l = m.Locked.Size() n += 1 + l + sovCoprocessor(uint64(l)) } l = len(m.OtherError) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } if m.Range != nil { l = m.Range.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.ExecDetails != nil { l = m.ExecDetails.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.IsCacheHit { n += 2 } if m.CacheLastVersion != 0 { n += 1 + sovCoprocessor(uint64(m.CacheLastVersion)) } if m.CanBeCached { n += 2 } if m.ExecDetailsV2 != nil { l = m.ExecDetailsV2.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.LatestBucketsVersion != 0 { n += 1 + sovCoprocessor(uint64(m.LatestBucketsVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionInfo) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovCoprocessor(uint64(m.RegionId)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TableRegions) Size() (n int) { var l int _ = l if m.PhysicalTableId != 0 { n += 1 + sovCoprocessor(uint64(m.PhysicalTableId)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if m.Tp != 0 { n += 1 + sovCoprocessor(uint64(m.Tp)) } l = len(m.Data) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.StartTs != 0 { n += 1 + sovCoprocessor(uint64(m.StartTs)) } if m.SchemaVer != 0 { n += 1 + sovCoprocessor(uint64(m.SchemaVer)) } if len(m.TableRegions) > 0 { for _, e := range m.TableRegions { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchResponse) Size() (n int) { var l int _ = l l = m.Data.Size() n += 1 + l + sovCoprocessor(uint64(l)) l = len(m.OtherError) if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } if m.ExecDetails != nil { l = m.ExecDetails.Size() n += 1 + l + sovCoprocessor(uint64(l)) } if len(m.RetryRegions) > 0 { for _, e := range m.RetryRegions { l = e.Size() n += 1 + l + sovCoprocessor(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovCoprocessor(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozCoprocessor(x uint64) (n int) { return sovCoprocessor(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *KeyRange) 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 ErrIntOverflowCoprocessor } 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: KeyRange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Start = append(m.Start[:0], dAtA[iNdEx:postIndex]...) if m.Start == nil { m.Start = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.End = append(m.End[:0], dAtA[iNdEx:postIndex]...) if m.End == nil { m.End = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *Request) 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 ErrIntOverflowCoprocessor } 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: Request: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &kvrpcpb.Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) } m.Tp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Tp |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: 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 ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen 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 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsCacheEnabled", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsCacheEnabled = bool(v != 0) case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CacheIfMatchVersion", wireType) } m.CacheIfMatchVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CacheIfMatchVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SchemaVer", wireType) } m.SchemaVer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SchemaVer |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsTraceEnabled", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsTraceEnabled = bool(v != 0) case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PagingSize", wireType) } m.PagingSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PagingSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *Response) 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 ErrIntOverflowCoprocessor } 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: Response: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Locked == nil { m.Locked = &kvrpcpb.LockInfo{} } if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OtherError", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } 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 ErrInvalidLengthCoprocessor } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.OtherError = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Range == nil { m.Range = &KeyRange{} } if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecDetails", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExecDetails == nil { m.ExecDetails = &kvrpcpb.ExecDetails{} } if err := m.ExecDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsCacheHit", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsCacheHit = bool(v != 0) case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CacheLastVersion", wireType) } m.CacheLastVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CacheLastVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CanBeCached", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.CanBeCached = bool(v != 0) case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecDetailsV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExecDetailsV2 == nil { m.ExecDetailsV2 = &kvrpcpb.ExecDetailsV2{} } if err := m.ExecDetailsV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LatestBucketsVersion", wireType) } m.LatestBucketsVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LatestBucketsVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *RegionInfo) 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 ErrIntOverflowCoprocessor } 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: RegionInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *TableRegions) 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 ErrIntOverflowCoprocessor } 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: TableRegions: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TableRegions: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PhysicalTableId", wireType) } m.PhysicalTableId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PhysicalTableId |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &RegionInfo{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *BatchRequest) 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 ErrIntOverflowCoprocessor } 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: BatchRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &kvrpcpb.Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) } m.Tp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Tp |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: 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 ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen 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 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &RegionInfo{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SchemaVer", wireType) } m.SchemaVer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SchemaVer |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TableRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.TableRegions = append(m.TableRegions, &TableRegions{}) if err := m.TableRegions[len(m.TableRegions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 *BatchResponse) 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 ErrIntOverflowCoprocessor } 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: BatchResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OtherError", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } 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 ErrInvalidLengthCoprocessor } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.OtherError = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecDetails", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExecDetails == nil { m.ExecDetails = &kvrpcpb.ExecDetails{} } if err := m.ExecDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RetryRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCoprocessor } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthCoprocessor } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RetryRegions = append(m.RetryRegions, &metapb.Region{}) if err := m.RetryRegions[len(m.RetryRegions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCoprocessor(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCoprocessor } 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 skipCoprocessor(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCoprocessor } 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, ErrIntOverflowCoprocessor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCoprocessor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthCoprocessor } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCoprocessor } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipCoprocessor(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthCoprocessor = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowCoprocessor = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("coprocessor.proto", fileDescriptor_coprocessor_590779721bad773d) } var fileDescriptor_coprocessor_590779721bad773d = []byte{ // 872 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0x4f, 0x6f, 0xe3, 0x44, 0x14, 0x5f, 0x27, 0x69, 0xe2, 0x3e, 0x3b, 0x6d, 0x3a, 0x5b, 0x8a, 0x77, 0x11, 0x6d, 0x94, 0x03, 0x0a, 0x0b, 0xb8, 0xda, 0x14, 0x2d, 0xb7, 0x1e, 0xb2, 0x54, 0xa2, 0xb0, 0x5c, 0x66, 0xab, 0x5e, 0xad, 0xc9, 0x78, 0x6a, 0x5b, 0x49, 0x3c, 0x66, 0x66, 0x1a, 0xb5, 0xfb, 0x15, 0xb8, 0x70, 0xe4, 0x23, 0x70, 0xe7, 0x4b, 0xec, 0x91, 0x23, 0xe2, 0xb0, 0x42, 0xe5, 0xca, 0x89, 0x4f, 0x80, 0xfc, 0xc6, 0x4e, 0x93, 0xf2, 0x47, 0xbd, 0xf4, 0xe4, 0x79, 0x7f, 0xfc, 0xde, 0x6f, 0xde, 0xef, 0xf7, 0x06, 0x76, 0xb8, 0x2c, 0x94, 0xe4, 0x42, 0x6b, 0xa9, 0xc2, 0x42, 0x49, 0x23, 0x89, 0xb7, 0xe2, 0x7a, 0xda, 0x15, 0x4a, 0x49, 0x55, 0x4c, 0x6c, 0xec, 0x69, 0x77, 0xba, 0x50, 0x05, 0x5f, 0x9a, 0xbb, 0x89, 0x4c, 0x24, 0x1e, 0x0f, 0xcb, 0x53, 0xe5, 0xdd, 0x56, 0x97, 0xda, 0xe0, 0xb1, 0x72, 0xf8, 0x73, 0x61, 0x58, 0xfd, 0xd3, 0x60, 0x04, 0xee, 0x37, 0xe2, 0x9a, 0xb2, 0x3c, 0x11, 0x64, 0x17, 0x36, 0xb4, 0x61, 0xca, 0x04, 0x4e, 0xdf, 0x19, 0xfa, 0xd4, 0x1a, 0xa4, 0x07, 0x4d, 0x91, 0xc7, 0x41, 0x03, 0x7d, 0xe5, 0x71, 0xf0, 0x67, 0x03, 0x3a, 0x54, 0x7c, 0x77, 0x29, 0xb4, 0x21, 0xcf, 0xa0, 0xc3, 0x65, 0x6e, 0xc4, 0x95, 0xfd, 0xcb, 0x1b, 0xf5, 0xc2, 0x1a, 0xd5, 0x4b, 0xeb, 0xa7, 0x75, 0x02, 0xd9, 0x82, 0x86, 0x29, 0xb0, 0x50, 0x93, 0x36, 0x4c, 0x41, 0x08, 0xb4, 0x62, 0x66, 0x58, 0xd0, 0xc4, 0xd2, 0x78, 0x26, 0x9f, 0x41, 0x5b, 0x95, 0x60, 0x74, 0xd0, 0xea, 0x37, 0x87, 0xde, 0xe8, 0xbd, 0x70, 0x75, 0x26, 0x35, 0x54, 0x5a, 0x25, 0x91, 0x21, 0xf4, 0x32, 0x1d, 0x71, 0xc6, 0x53, 0x11, 0x89, 0x9c, 0x4d, 0x66, 0x22, 0x0e, 0x36, 0xfa, 0xce, 0xd0, 0xa5, 0x5b, 0x99, 0x7e, 0x59, 0xba, 0x4f, 0xac, 0x97, 0x1c, 0xc1, 0x9e, 0x4d, 0xcb, 0x2e, 0xa2, 0x39, 0x33, 0x3c, 0x8d, 0x16, 0x42, 0xe9, 0x4c, 0xe6, 0x41, 0xbb, 0xef, 0x0c, 0x5b, 0xf4, 0x31, 0x46, 0x4f, 0x2f, 0xbe, 0x2d, 0x63, 0xe7, 0x36, 0x44, 0x9e, 0x80, 0x8b, 0x43, 0x88, 0x8c, 0x0e, 0x3a, 0x98, 0xd6, 0x41, 0xfb, 0x4c, 0x93, 0x0f, 0x01, 0x34, 0x4f, 0xc5, 0x9c, 0x95, 0x75, 0x02, 0x17, 0x2f, 0xb5, 0x69, 0x3d, 0xe7, 0x42, 0x55, 0xc0, 0x8c, 0x62, 0xfc, 0x16, 0xd8, 0x66, 0x0d, 0xec, 0xac, 0x74, 0xd7, 0xc0, 0x0e, 0xc0, 0x2b, 0x58, 0x92, 0xe5, 0x49, 0xa4, 0xb3, 0x37, 0x22, 0x00, 0x6c, 0x03, 0xd6, 0xf5, 0x3a, 0x7b, 0x23, 0x06, 0x3f, 0xb7, 0xc0, 0xa5, 0x42, 0x17, 0x32, 0xd7, 0x82, 0xd0, 0x6a, 0x66, 0x48, 0xd1, 0xf8, 0xf8, 0xed, 0xbb, 0x83, 0x47, 0xbf, 0xbd, 0x3b, 0x78, 0x91, 0x64, 0x26, 0xbd, 0x9c, 0x84, 0x5c, 0xce, 0x0f, 0x8b, 0x2c, 0x4f, 0x38, 0x2b, 0x0e, 0xa7, 0x0b, 0xab, 0x85, 0x62, 0x9a, 0x1c, 0xea, 0x94, 0x29, 0x11, 0x4f, 0xae, 0x8d, 0xd0, 0xe1, 0x6b, 0x3c, 0x8f, 0xcb, 0x73, 0x35, 0xf3, 0xe7, 0xe0, 0x2b, 0x91, 0x64, 0x32, 0x8f, 0x50, 0x5f, 0xc8, 0x90, 0x37, 0xda, 0x0a, 0x6b, 0xb5, 0x9d, 0x94, 0x5f, 0xea, 0xd9, 0x1c, 0x34, 0xc8, 0xc7, 0xd0, 0x9e, 0x49, 0x3e, 0x15, 0x31, 0x92, 0xe7, 0x8d, 0x76, 0x96, 0xac, 0xbf, 0x92, 0x7c, 0x7a, 0x9a, 0x5f, 0x48, 0x5a, 0x25, 0x94, 0xf7, 0x93, 0x26, 0x15, 0xaa, 0x2a, 0xde, 0xea, 0x3b, 0xc3, 0x4d, 0x0a, 0xe8, 0xb2, 0xb5, 0x3e, 0x81, 0x0d, 0x64, 0x13, 0x89, 0xfb, 0x4f, 0xc6, 0x6d, 0x0e, 0xf9, 0x02, 0x7c, 0x71, 0x25, 0x78, 0x14, 0x0b, 0xc3, 0xb2, 0x99, 0x46, 0xf2, 0xbc, 0xd1, 0xee, 0xb2, 0xfd, 0xc9, 0x95, 0xe0, 0x5f, 0xda, 0x18, 0xf5, 0xc4, 0xad, 0x41, 0xfa, 0xe0, 0x2f, 0x95, 0x92, 0x66, 0x06, 0xe9, 0x74, 0x29, 0x54, 0x2a, 0xf9, 0x2a, 0x33, 0xe4, 0x53, 0x20, 0x36, 0x3c, 0x63, 0xda, 0x2c, 0xd5, 0xe1, 0x22, 0x1f, 0x3d, 0x8c, 0xbc, 0x62, 0xda, 0xd4, 0xd2, 0x18, 0x40, 0x97, 0xb3, 0x3c, 0x9a, 0x08, 0x5b, 0xb3, 0x66, 0xd7, 0xe3, 0x2c, 0x1f, 0x0b, 0xac, 0x19, 0x93, 0x63, 0xd8, 0x5e, 0x05, 0x1b, 0x2d, 0x46, 0x81, 0x87, 0x78, 0xf7, 0xfe, 0x0d, 0xef, 0xf9, 0x88, 0x76, 0xc5, 0xaa, 0x49, 0x3e, 0x87, 0xbd, 0x19, 0x33, 0x42, 0x9b, 0x68, 0x72, 0xc9, 0xa7, 0xc2, 0xe8, 0x25, 0x2a, 0x1f, 0x51, 0xed, 0xda, 0xe8, 0xd8, 0x06, 0x2b, 0x64, 0x5f, 0xb7, 0x5c, 0xe8, 0x79, 0x83, 0x1f, 0x1c, 0x00, 0x8a, 0x8c, 0x95, 0x6c, 0x90, 0x0f, 0x60, 0xb3, 0xe2, 0x38, 0x8b, 0x51, 0x3c, 0x2d, 0xea, 0x5a, 0xc7, 0x69, 0x4c, 0x5e, 0xdc, 0x0a, 0xa0, 0x90, 0x3c, 0xad, 0x04, 0xf0, 0x38, 0xac, 0x5e, 0x0a, 0x5b, 0xe6, 0xa4, 0x0c, 0x2d, 0x55, 0x50, 0x1a, 0x2b, 0xcb, 0xda, 0xbc, 0xc7, 0xb2, 0x0e, 0xe6, 0xe0, 0x9f, 0x95, 0x9a, 0xb7, 0xf5, 0x34, 0x79, 0x06, 0x3b, 0x45, 0x7a, 0xad, 0x33, 0xce, 0x66, 0x91, 0x29, 0x03, 0x35, 0xb6, 0x26, 0xdd, 0xae, 0x03, 0xf8, 0xc3, 0x69, 0x4c, 0x9e, 0x43, 0xc7, 0x76, 0xd6, 0x41, 0x03, 0x7b, 0xbd, 0xbf, 0xd6, 0xeb, 0xf6, 0xa6, 0xb4, 0xce, 0x1b, 0x7c, 0xdf, 0x00, 0x7f, 0x5c, 0x6e, 0xf3, 0x43, 0xbd, 0x55, 0x2b, 0x98, 0x5a, 0xf7, 0xc3, 0xb4, 0xf6, 0xa0, 0x6c, 0xfc, 0xdf, 0x83, 0xd2, 0xbe, 0xfb, 0xa0, 0x1c, 0x43, 0xd7, 0xce, 0xa8, 0x6e, 0xd9, 0xc1, 0x96, 0x4f, 0xd6, 0x5a, 0xae, 0x8e, 0x97, 0xfa, 0x66, 0xc5, 0x1a, 0xfc, 0xe5, 0x40, 0xb7, 0x9a, 0xc6, 0x03, 0x3e, 0x25, 0x77, 0x96, 0xbd, 0xf1, 0x8f, 0x65, 0xbf, 0xbb, 0xbf, 0xcd, 0xfb, 0xee, 0xef, 0x11, 0x74, 0x95, 0x30, 0xea, 0x3a, 0x5a, 0x1f, 0xf9, 0xd6, 0xba, 0x48, 0xa9, 0x8f, 0x49, 0xd5, 0xa5, 0xc7, 0x1f, 0xfd, 0xfa, 0x93, 0xeb, 0xbc, 0xbd, 0xd9, 0x77, 0x7e, 0xb9, 0xd9, 0x77, 0x7e, 0xbf, 0xd9, 0x77, 0x7e, 0xfc, 0x63, 0xff, 0x11, 0xf4, 0xa4, 0x4a, 0x42, 0x93, 0x4d, 0x17, 0x61, 0x75, 0xb1, 0x49, 0x1b, 0x3f, 0x47, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x3c, 0xef, 0x48, 0x3f, 0x81, 0x07, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/deadlock/000077500000000000000000000000001421456440000166345ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/deadlock/deadlock.pb.go000066400000000000000000001142141421456440000213340ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: deadlock.proto package deadlock import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type DeadlockRequestType int32 const ( DeadlockRequestType_Detect DeadlockRequestType = 0 // CleanUpWaitFor cleans a single entry the transaction is waiting. DeadlockRequestType_CleanUpWaitFor DeadlockRequestType = 1 // CleanUp cleans all entries the transaction is waiting. DeadlockRequestType_CleanUp DeadlockRequestType = 2 ) var DeadlockRequestType_name = map[int32]string{ 0: "Detect", 1: "CleanUpWaitFor", 2: "CleanUp", } var DeadlockRequestType_value = map[string]int32{ "Detect": 0, "CleanUpWaitFor": 1, "CleanUp": 2, } func (x DeadlockRequestType) String() string { return proto.EnumName(DeadlockRequestType_name, int32(x)) } func (DeadlockRequestType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{0} } type WaitForEntriesRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WaitForEntriesRequest) Reset() { *m = WaitForEntriesRequest{} } func (m *WaitForEntriesRequest) String() string { return proto.CompactTextString(m) } func (*WaitForEntriesRequest) ProtoMessage() {} func (*WaitForEntriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{0} } func (m *WaitForEntriesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WaitForEntriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WaitForEntriesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WaitForEntriesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WaitForEntriesRequest.Merge(dst, src) } func (m *WaitForEntriesRequest) XXX_Size() int { return m.Size() } func (m *WaitForEntriesRequest) XXX_DiscardUnknown() { xxx_messageInfo_WaitForEntriesRequest.DiscardUnknown(m) } var xxx_messageInfo_WaitForEntriesRequest proto.InternalMessageInfo type WaitForEntriesResponse struct { Entries []WaitForEntry `protobuf:"bytes,1,rep,name=entries" json:"entries"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WaitForEntriesResponse) Reset() { *m = WaitForEntriesResponse{} } func (m *WaitForEntriesResponse) String() string { return proto.CompactTextString(m) } func (*WaitForEntriesResponse) ProtoMessage() {} func (*WaitForEntriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{1} } func (m *WaitForEntriesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WaitForEntriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WaitForEntriesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WaitForEntriesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WaitForEntriesResponse.Merge(dst, src) } func (m *WaitForEntriesResponse) XXX_Size() int { return m.Size() } func (m *WaitForEntriesResponse) XXX_DiscardUnknown() { xxx_messageInfo_WaitForEntriesResponse.DiscardUnknown(m) } var xxx_messageInfo_WaitForEntriesResponse proto.InternalMessageInfo func (m *WaitForEntriesResponse) GetEntries() []WaitForEntry { if m != nil { return m.Entries } return nil } type WaitForEntry struct { // The transaction id that is waiting. Txn uint64 `protobuf:"varint,1,opt,name=txn,proto3" json:"txn,omitempty"` // The transaction id that is being waited for. WaitForTxn uint64 `protobuf:"varint,2,opt,name=wait_for_txn,json=waitForTxn,proto3" json:"wait_for_txn,omitempty"` // The hash value of the key is being waited for. KeyHash uint64 `protobuf:"varint,3,opt,name=key_hash,json=keyHash,proto3" json:"key_hash,omitempty"` // The key the current txn is trying to lock. Key []byte `protobuf:"bytes,4,opt,name=key,proto3" json:"key,omitempty"` // The tag came from the lock request's context. ResourceGroupTag []byte `protobuf:"bytes,5,opt,name=resource_group_tag,json=resourceGroupTag,proto3" json:"resource_group_tag,omitempty"` // Milliseconds it has been waits. WaitTime uint64 `protobuf:"varint,6,opt,name=wait_time,json=waitTime,proto3" json:"wait_time,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WaitForEntry) Reset() { *m = WaitForEntry{} } func (m *WaitForEntry) String() string { return proto.CompactTextString(m) } func (*WaitForEntry) ProtoMessage() {} func (*WaitForEntry) Descriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{2} } func (m *WaitForEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WaitForEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WaitForEntry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WaitForEntry) XXX_Merge(src proto.Message) { xxx_messageInfo_WaitForEntry.Merge(dst, src) } func (m *WaitForEntry) XXX_Size() int { return m.Size() } func (m *WaitForEntry) XXX_DiscardUnknown() { xxx_messageInfo_WaitForEntry.DiscardUnknown(m) } var xxx_messageInfo_WaitForEntry proto.InternalMessageInfo func (m *WaitForEntry) GetTxn() uint64 { if m != nil { return m.Txn } return 0 } func (m *WaitForEntry) GetWaitForTxn() uint64 { if m != nil { return m.WaitForTxn } return 0 } func (m *WaitForEntry) GetKeyHash() uint64 { if m != nil { return m.KeyHash } return 0 } func (m *WaitForEntry) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *WaitForEntry) GetResourceGroupTag() []byte { if m != nil { return m.ResourceGroupTag } return nil } func (m *WaitForEntry) GetWaitTime() uint64 { if m != nil { return m.WaitTime } return 0 } type DeadlockRequest struct { Tp DeadlockRequestType `protobuf:"varint,1,opt,name=tp,proto3,enum=deadlock.DeadlockRequestType" json:"tp,omitempty"` Entry WaitForEntry `protobuf:"bytes,2,opt,name=entry" json:"entry"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeadlockRequest) Reset() { *m = DeadlockRequest{} } func (m *DeadlockRequest) String() string { return proto.CompactTextString(m) } func (*DeadlockRequest) ProtoMessage() {} func (*DeadlockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{3} } func (m *DeadlockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeadlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeadlockRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeadlockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeadlockRequest.Merge(dst, src) } func (m *DeadlockRequest) XXX_Size() int { return m.Size() } func (m *DeadlockRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeadlockRequest.DiscardUnknown(m) } var xxx_messageInfo_DeadlockRequest proto.InternalMessageInfo func (m *DeadlockRequest) GetTp() DeadlockRequestType { if m != nil { return m.Tp } return DeadlockRequestType_Detect } func (m *DeadlockRequest) GetEntry() WaitForEntry { if m != nil { return m.Entry } return WaitForEntry{} } type DeadlockResponse struct { // The same entry sent by DeadlockRequest, identifies the sender. Entry WaitForEntry `protobuf:"bytes,1,opt,name=entry" json:"entry"` // The key hash of the lock that is hold by the waiting transaction. DeadlockKeyHash uint64 `protobuf:"varint,2,opt,name=deadlock_key_hash,json=deadlockKeyHash,proto3" json:"deadlock_key_hash,omitempty"` // The other entries of the dead lock circle. The current entry is in `entry` field and not // included in this field. WaitChain []*WaitForEntry `protobuf:"bytes,3,rep,name=wait_chain,json=waitChain" json:"wait_chain,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeadlockResponse) Reset() { *m = DeadlockResponse{} } func (m *DeadlockResponse) String() string { return proto.CompactTextString(m) } func (*DeadlockResponse) ProtoMessage() {} func (*DeadlockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_deadlock_049c682449cfa76f, []int{4} } func (m *DeadlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeadlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeadlockResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeadlockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeadlockResponse.Merge(dst, src) } func (m *DeadlockResponse) XXX_Size() int { return m.Size() } func (m *DeadlockResponse) XXX_DiscardUnknown() { xxx_messageInfo_DeadlockResponse.DiscardUnknown(m) } var xxx_messageInfo_DeadlockResponse proto.InternalMessageInfo func (m *DeadlockResponse) GetEntry() WaitForEntry { if m != nil { return m.Entry } return WaitForEntry{} } func (m *DeadlockResponse) GetDeadlockKeyHash() uint64 { if m != nil { return m.DeadlockKeyHash } return 0 } func (m *DeadlockResponse) GetWaitChain() []*WaitForEntry { if m != nil { return m.WaitChain } return nil } func init() { proto.RegisterType((*WaitForEntriesRequest)(nil), "deadlock.WaitForEntriesRequest") proto.RegisterType((*WaitForEntriesResponse)(nil), "deadlock.WaitForEntriesResponse") proto.RegisterType((*WaitForEntry)(nil), "deadlock.WaitForEntry") proto.RegisterType((*DeadlockRequest)(nil), "deadlock.DeadlockRequest") proto.RegisterType((*DeadlockResponse)(nil), "deadlock.DeadlockResponse") proto.RegisterEnum("deadlock.DeadlockRequestType", DeadlockRequestType_name, DeadlockRequestType_value) } // 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 // Client API for Deadlock service type DeadlockClient interface { // Get local wait for entries, should be handle by every node. // The owner should sent this request to all members to build the complete wait for graph. GetWaitForEntries(ctx context.Context, in *WaitForEntriesRequest, opts ...grpc.CallOption) (*WaitForEntriesResponse, error) // Detect should only sent to the owner. only be handled by the owner. // The DeadlockResponse is sent back only if there is deadlock detected. // CleanUpWaitFor and CleanUp doesn't return responses. Detect(ctx context.Context, opts ...grpc.CallOption) (Deadlock_DetectClient, error) } type deadlockClient struct { cc *grpc.ClientConn } func NewDeadlockClient(cc *grpc.ClientConn) DeadlockClient { return &deadlockClient{cc} } func (c *deadlockClient) GetWaitForEntries(ctx context.Context, in *WaitForEntriesRequest, opts ...grpc.CallOption) (*WaitForEntriesResponse, error) { out := new(WaitForEntriesResponse) err := c.cc.Invoke(ctx, "/deadlock.Deadlock/GetWaitForEntries", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *deadlockClient) Detect(ctx context.Context, opts ...grpc.CallOption) (Deadlock_DetectClient, error) { stream, err := c.cc.NewStream(ctx, &_Deadlock_serviceDesc.Streams[0], "/deadlock.Deadlock/Detect", opts...) if err != nil { return nil, err } x := &deadlockDetectClient{stream} return x, nil } type Deadlock_DetectClient interface { Send(*DeadlockRequest) error Recv() (*DeadlockResponse, error) grpc.ClientStream } type deadlockDetectClient struct { grpc.ClientStream } func (x *deadlockDetectClient) Send(m *DeadlockRequest) error { return x.ClientStream.SendMsg(m) } func (x *deadlockDetectClient) Recv() (*DeadlockResponse, error) { m := new(DeadlockResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for Deadlock service type DeadlockServer interface { // Get local wait for entries, should be handle by every node. // The owner should sent this request to all members to build the complete wait for graph. GetWaitForEntries(context.Context, *WaitForEntriesRequest) (*WaitForEntriesResponse, error) // Detect should only sent to the owner. only be handled by the owner. // The DeadlockResponse is sent back only if there is deadlock detected. // CleanUpWaitFor and CleanUp doesn't return responses. Detect(Deadlock_DetectServer) error } func RegisterDeadlockServer(s *grpc.Server, srv DeadlockServer) { s.RegisterService(&_Deadlock_serviceDesc, srv) } func _Deadlock_GetWaitForEntries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(WaitForEntriesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DeadlockServer).GetWaitForEntries(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/deadlock.Deadlock/GetWaitForEntries", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DeadlockServer).GetWaitForEntries(ctx, req.(*WaitForEntriesRequest)) } return interceptor(ctx, in, info, handler) } func _Deadlock_Detect_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(DeadlockServer).Detect(&deadlockDetectServer{stream}) } type Deadlock_DetectServer interface { Send(*DeadlockResponse) error Recv() (*DeadlockRequest, error) grpc.ServerStream } type deadlockDetectServer struct { grpc.ServerStream } func (x *deadlockDetectServer) Send(m *DeadlockResponse) error { return x.ServerStream.SendMsg(m) } func (x *deadlockDetectServer) Recv() (*DeadlockRequest, error) { m := new(DeadlockRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } var _Deadlock_serviceDesc = grpc.ServiceDesc{ ServiceName: "deadlock.Deadlock", HandlerType: (*DeadlockServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "GetWaitForEntries", Handler: _Deadlock_GetWaitForEntries_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "Detect", Handler: _Deadlock_Detect_Handler, ServerStreams: true, ClientStreams: true, }, }, Metadata: "deadlock.proto", } func (m *WaitForEntriesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WaitForEntriesRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WaitForEntriesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WaitForEntriesResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0xa i++ i = encodeVarintDeadlock(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WaitForEntry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WaitForEntry) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Txn != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.Txn)) } if m.WaitForTxn != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.WaitForTxn)) } if m.KeyHash != 0 { dAtA[i] = 0x18 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.KeyHash)) } if len(m.Key) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintDeadlock(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.ResourceGroupTag) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintDeadlock(dAtA, i, uint64(len(m.ResourceGroupTag))) i += copy(dAtA[i:], m.ResourceGroupTag) } if m.WaitTime != 0 { dAtA[i] = 0x30 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.WaitTime)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeadlockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeadlockRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Tp != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.Tp)) } dAtA[i] = 0x12 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.Entry.Size())) n1, err := m.Entry.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeadlockResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeadlockResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0xa i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.Entry.Size())) n2, err := m.Entry.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 if m.DeadlockKeyHash != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDeadlock(dAtA, i, uint64(m.DeadlockKeyHash)) } if len(m.WaitChain) > 0 { for _, msg := range m.WaitChain { dAtA[i] = 0x1a i++ i = encodeVarintDeadlock(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintDeadlock(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *WaitForEntriesRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WaitForEntriesResponse) Size() (n int) { var l int _ = l if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovDeadlock(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WaitForEntry) Size() (n int) { var l int _ = l if m.Txn != 0 { n += 1 + sovDeadlock(uint64(m.Txn)) } if m.WaitForTxn != 0 { n += 1 + sovDeadlock(uint64(m.WaitForTxn)) } if m.KeyHash != 0 { n += 1 + sovDeadlock(uint64(m.KeyHash)) } l = len(m.Key) if l > 0 { n += 1 + l + sovDeadlock(uint64(l)) } l = len(m.ResourceGroupTag) if l > 0 { n += 1 + l + sovDeadlock(uint64(l)) } if m.WaitTime != 0 { n += 1 + sovDeadlock(uint64(m.WaitTime)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeadlockRequest) Size() (n int) { var l int _ = l if m.Tp != 0 { n += 1 + sovDeadlock(uint64(m.Tp)) } l = m.Entry.Size() n += 1 + l + sovDeadlock(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeadlockResponse) Size() (n int) { var l int _ = l l = m.Entry.Size() n += 1 + l + sovDeadlock(uint64(l)) if m.DeadlockKeyHash != 0 { n += 1 + sovDeadlock(uint64(m.DeadlockKeyHash)) } if len(m.WaitChain) > 0 { for _, e := range m.WaitChain { l = e.Size() n += 1 + l + sovDeadlock(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovDeadlock(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozDeadlock(x uint64) (n int) { return sovDeadlock(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *WaitForEntriesRequest) 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 ErrIntOverflowDeadlock } 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: WaitForEntriesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WaitForEntriesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDeadlock } 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 *WaitForEntriesResponse) 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 ErrIntOverflowDeadlock } 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: WaitForEntriesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WaitForEntriesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, WaitForEntry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDeadlock } 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 *WaitForEntry) 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 ErrIntOverflowDeadlock } 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: WaitForEntry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WaitForEntry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType) } m.Txn = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Txn |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WaitForTxn", wireType) } m.WaitForTxn = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WaitForTxn |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyHash", wireType) } m.KeyHash = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeyHash |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceGroupTag", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ResourceGroupTag = append(m.ResourceGroupTag[:0], dAtA[iNdEx:postIndex]...) if m.ResourceGroupTag == nil { m.ResourceGroupTag = []byte{} } iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WaitTime", wireType) } m.WaitTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WaitTime |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDeadlock } 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 *DeadlockRequest) 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 ErrIntOverflowDeadlock } 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: DeadlockRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeadlockRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) } m.Tp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Tp |= (DeadlockRequestType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDeadlock } 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 *DeadlockResponse) 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 ErrIntOverflowDeadlock } 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: DeadlockResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeadlockResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DeadlockKeyHash", wireType) } m.DeadlockKeyHash = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DeadlockKeyHash |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WaitChain", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDeadlock } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDeadlock } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.WaitChain = append(m.WaitChain, &WaitForEntry{}) if err := m.WaitChain[len(m.WaitChain)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDeadlock } 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 skipDeadlock(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDeadlock } 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, ErrIntOverflowDeadlock } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDeadlock } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthDeadlock } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDeadlock } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipDeadlock(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthDeadlock = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowDeadlock = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("deadlock.proto", fileDescriptor_deadlock_049c682449cfa76f) } var fileDescriptor_deadlock_049c682449cfa76f = []byte{ // 465 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40, 0x10, 0x86, 0xb3, 0x49, 0x9a, 0x84, 0x69, 0x94, 0xba, 0x03, 0x14, 0x37, 0x88, 0xd4, 0xf2, 0x53, 0x54, 0x41, 0x41, 0x41, 0x70, 0x80, 0xb4, 0xa5, 0x48, 0xbc, 0x20, 0x2b, 0x08, 0xde, 0xac, 0x25, 0x1d, 0x6c, 0xcb, 0xad, 0xd7, 0xd8, 0x1b, 0xb5, 0xbe, 0x09, 0x57, 0x40, 0xdc, 0x80, 0x13, 0xf4, 0x91, 0x13, 0x20, 0x14, 0x2e, 0x82, 0x76, 0xed, 0x4d, 0x4a, 0x95, 0x40, 0xdf, 0xd6, 0xf3, 0xff, 0xfb, 0xef, 0xcc, 0xb7, 0x6b, 0xe8, 0x9d, 0x12, 0x3f, 0x3d, 0x13, 0xd3, 0xf8, 0x20, 0xcd, 0x84, 0x14, 0xd8, 0x31, 0xdf, 0xfd, 0x7b, 0x81, 0x08, 0x84, 0x2e, 0x3e, 0x55, 0xab, 0x52, 0x77, 0x1f, 0xc0, 0xfd, 0xf7, 0x3c, 0x92, 0xaf, 0x44, 0x76, 0x9c, 0xc8, 0x2c, 0xa2, 0xdc, 0xa3, 0xcf, 0x33, 0xca, 0xa5, 0xfb, 0x16, 0x76, 0x6e, 0x0a, 0x79, 0x2a, 0x92, 0x9c, 0xf0, 0x25, 0xb4, 0xa9, 0x2c, 0xd9, 0xcc, 0x69, 0x0c, 0x37, 0x47, 0x3b, 0x07, 0x8b, 0x43, 0xaf, 0x6d, 0x29, 0xc6, 0xcd, 0xab, 0x9f, 0x7b, 0x35, 0xcf, 0x98, 0xdd, 0xef, 0x0c, 0xba, 0xd7, 0x75, 0xb4, 0xa0, 0x21, 0x2f, 0x13, 0x9b, 0x39, 0x6c, 0xd8, 0xf4, 0xd4, 0x12, 0x1d, 0xe8, 0x5e, 0xf0, 0x48, 0xfa, 0x9f, 0x44, 0xe6, 0x2b, 0xa9, 0xae, 0x25, 0xb8, 0x28, 0x77, 0x4d, 0x2e, 0x13, 0xdc, 0x85, 0x4e, 0x4c, 0x85, 0x1f, 0xf2, 0x3c, 0xb4, 0x1b, 0x5a, 0x6d, 0xc7, 0x54, 0xbc, 0xe6, 0x79, 0xa8, 0xe2, 0x62, 0x2a, 0xec, 0xa6, 0xc3, 0x86, 0x5d, 0x4f, 0x2d, 0xf1, 0x31, 0x60, 0x46, 0xb9, 0x98, 0x65, 0x53, 0xf2, 0x83, 0x4c, 0xcc, 0x52, 0x5f, 0xf2, 0xc0, 0xde, 0xd0, 0x06, 0xcb, 0x28, 0x27, 0x4a, 0x98, 0xf0, 0x00, 0x1f, 0xc2, 0x1d, 0x7d, 0xb8, 0x8c, 0xce, 0xc9, 0x6e, 0xe9, 0xec, 0x8e, 0x2a, 0x4c, 0xa2, 0x73, 0x72, 0x25, 0x6c, 0x1d, 0x55, 0x43, 0x56, 0x84, 0xf0, 0x09, 0xd4, 0x65, 0xaa, 0xbb, 0xef, 0x8d, 0x1e, 0x2d, 0x11, 0xdc, 0xb0, 0x4d, 0x8a, 0x94, 0xbc, 0xba, 0x4c, 0x71, 0x04, 0x1b, 0x8a, 0x44, 0xa1, 0x87, 0xfa, 0x1f, 0xb4, 0xd2, 0xea, 0x7e, 0x65, 0x60, 0x2d, 0xf3, 0x2a, 0xfe, 0x8b, 0x20, 0x76, 0xeb, 0x20, 0xdc, 0x87, 0x6d, 0xe3, 0xf2, 0x17, 0xfc, 0x4a, 0xba, 0x5b, 0x46, 0x78, 0x53, 0x71, 0x7c, 0x01, 0x1a, 0xb8, 0x3f, 0x0d, 0x79, 0x94, 0xd8, 0x8d, 0x7f, 0x5d, 0xb1, 0xa7, 0x89, 0x1d, 0x2a, 0xe3, 0xfe, 0x18, 0xee, 0xae, 0x18, 0x1d, 0x01, 0x5a, 0x47, 0x24, 0x69, 0x2a, 0xad, 0x1a, 0x22, 0xf4, 0x0e, 0xcf, 0x88, 0x27, 0xef, 0xd2, 0x2a, 0xc4, 0x62, 0xb8, 0x09, 0xed, 0xaa, 0x66, 0xd5, 0x47, 0xdf, 0x18, 0x74, 0x4c, 0x08, 0x7e, 0x80, 0xed, 0x13, 0x92, 0x7f, 0x3f, 0x42, 0xdc, 0x5b, 0xd9, 0xc8, 0xf2, 0xdd, 0xf6, 0x9d, 0xf5, 0x86, 0x92, 0x9f, 0x5b, 0xc3, 0x63, 0xd3, 0x13, 0xee, 0xae, 0xbd, 0xb7, 0x7e, 0x7f, 0x95, 0x64, 0x22, 0x86, 0xec, 0x19, 0x1b, 0x5b, 0x57, 0xf3, 0x01, 0xfb, 0x31, 0x1f, 0xb0, 0x5f, 0xf3, 0x01, 0xfb, 0xf2, 0x7b, 0x50, 0xfb, 0xd8, 0xd2, 0x3f, 0xd5, 0xf3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x1a, 0x00, 0x2a, 0x86, 0x03, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/debugpb/000077500000000000000000000000001421456440000164765ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/debugpb/debugpb.pb.go000066400000000000000000006234131421456440000210460ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: debugpb.proto package debugpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" eraftpb "github.com/pingcap/kvproto/pkg/eraftpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" raft_serverpb "github.com/pingcap/kvproto/pkg/raft_serverpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type DB int32 const ( DB_INVALID DB = 0 DB_KV DB = 1 DB_RAFT DB = 2 ) var DB_name = map[int32]string{ 0: "INVALID", 1: "KV", 2: "RAFT", } var DB_value = map[string]int32{ "INVALID": 0, "KV": 1, "RAFT": 2, } func (x DB) String() string { return proto.EnumName(DB_name, int32(x)) } func (DB) EnumDescriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{0} } type MODULE int32 const ( MODULE_UNUSED MODULE = 0 MODULE_KVDB MODULE = 1 MODULE_RAFTDB MODULE = 2 MODULE_READPOOL MODULE = 3 MODULE_SERVER MODULE = 4 MODULE_STORAGE MODULE = 5 MODULE_PD MODULE = 6 MODULE_METRIC MODULE = 7 MODULE_COPROCESSOR MODULE = 8 MODULE_SECURITY MODULE = 9 MODULE_IMPORT MODULE = 10 ) var MODULE_name = map[int32]string{ 0: "UNUSED", 1: "KVDB", 2: "RAFTDB", 3: "READPOOL", 4: "SERVER", 5: "STORAGE", 6: "PD", 7: "METRIC", 8: "COPROCESSOR", 9: "SECURITY", 10: "IMPORT", } var MODULE_value = map[string]int32{ "UNUSED": 0, "KVDB": 1, "RAFTDB": 2, "READPOOL": 3, "SERVER": 4, "STORAGE": 5, "PD": 6, "METRIC": 7, "COPROCESSOR": 8, "SECURITY": 9, "IMPORT": 10, } func (x MODULE) String() string { return proto.EnumName(MODULE_name, int32(x)) } func (MODULE) EnumDescriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{1} } type BottommostLevelCompaction int32 const ( // Skip bottommost level compaction BottommostLevelCompaction_Skip BottommostLevelCompaction = 0 // Force bottommost level compaction BottommostLevelCompaction_Force BottommostLevelCompaction = 1 // Compact bottommost level if there is a compaction filter. BottommostLevelCompaction_IfHaveCompactionFilter BottommostLevelCompaction = 2 ) var BottommostLevelCompaction_name = map[int32]string{ 0: "Skip", 1: "Force", 2: "IfHaveCompactionFilter", } var BottommostLevelCompaction_value = map[string]int32{ "Skip": 0, "Force": 1, "IfHaveCompactionFilter": 2, } func (x BottommostLevelCompaction) String() string { return proto.EnumName(BottommostLevelCompaction_name, int32(x)) } func (BottommostLevelCompaction) EnumDescriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{2} } type GetRequest struct { Db DB `protobuf:"varint,1,opt,name=db,proto3,enum=debugpb.DB" json:"db,omitempty"` Cf string `protobuf:"bytes,2,opt,name=cf,proto3" json:"cf,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{0} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRequest.Merge(dst, 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 func (m *GetRequest) GetDb() DB { if m != nil { return m.Db } return DB_INVALID } func (m *GetRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *GetRequest) GetKey() []byte { if m != nil { return m.Key } return nil } type GetResponse struct { Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{1} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetResponse.Merge(dst, 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 func (m *GetResponse) GetValue() []byte { if m != nil { return m.Value } return nil } type RaftLogRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` LogIndex uint64 `protobuf:"varint,2,opt,name=log_index,json=logIndex,proto3" json:"log_index,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftLogRequest) Reset() { *m = RaftLogRequest{} } func (m *RaftLogRequest) String() string { return proto.CompactTextString(m) } func (*RaftLogRequest) ProtoMessage() {} func (*RaftLogRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{2} } func (m *RaftLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftLogRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftLogRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftLogRequest.Merge(dst, src) } func (m *RaftLogRequest) XXX_Size() int { return m.Size() } func (m *RaftLogRequest) XXX_DiscardUnknown() { xxx_messageInfo_RaftLogRequest.DiscardUnknown(m) } var xxx_messageInfo_RaftLogRequest proto.InternalMessageInfo func (m *RaftLogRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RaftLogRequest) GetLogIndex() uint64 { if m != nil { return m.LogIndex } return 0 } type RaftLogResponse struct { Entry *eraftpb.Entry `protobuf:"bytes,1,opt,name=entry" json:"entry,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftLogResponse) Reset() { *m = RaftLogResponse{} } func (m *RaftLogResponse) String() string { return proto.CompactTextString(m) } func (*RaftLogResponse) ProtoMessage() {} func (*RaftLogResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{3} } func (m *RaftLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftLogResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftLogResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftLogResponse.Merge(dst, src) } func (m *RaftLogResponse) XXX_Size() int { return m.Size() } func (m *RaftLogResponse) XXX_DiscardUnknown() { xxx_messageInfo_RaftLogResponse.DiscardUnknown(m) } var xxx_messageInfo_RaftLogResponse proto.InternalMessageInfo func (m *RaftLogResponse) GetEntry() *eraftpb.Entry { if m != nil { return m.Entry } return nil } type RegionInfoRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionInfoRequest) Reset() { *m = RegionInfoRequest{} } func (m *RegionInfoRequest) String() string { return proto.CompactTextString(m) } func (*RegionInfoRequest) ProtoMessage() {} func (*RegionInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{4} } func (m *RegionInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionInfoRequest.Merge(dst, src) } func (m *RegionInfoRequest) XXX_Size() int { return m.Size() } func (m *RegionInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionInfoRequest proto.InternalMessageInfo func (m *RegionInfoRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type RegionInfoResponse struct { RaftLocalState *raft_serverpb.RaftLocalState `protobuf:"bytes,1,opt,name=raft_local_state,json=raftLocalState" json:"raft_local_state,omitempty"` RaftApplyState *raft_serverpb.RaftApplyState `protobuf:"bytes,2,opt,name=raft_apply_state,json=raftApplyState" json:"raft_apply_state,omitempty"` RegionLocalState *raft_serverpb.RegionLocalState `protobuf:"bytes,3,opt,name=region_local_state,json=regionLocalState" json:"region_local_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionInfoResponse) Reset() { *m = RegionInfoResponse{} } func (m *RegionInfoResponse) String() string { return proto.CompactTextString(m) } func (*RegionInfoResponse) ProtoMessage() {} func (*RegionInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{5} } func (m *RegionInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionInfoResponse.Merge(dst, src) } func (m *RegionInfoResponse) XXX_Size() int { return m.Size() } func (m *RegionInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionInfoResponse proto.InternalMessageInfo func (m *RegionInfoResponse) GetRaftLocalState() *raft_serverpb.RaftLocalState { if m != nil { return m.RaftLocalState } return nil } func (m *RegionInfoResponse) GetRaftApplyState() *raft_serverpb.RaftApplyState { if m != nil { return m.RaftApplyState } return nil } func (m *RegionInfoResponse) GetRegionLocalState() *raft_serverpb.RegionLocalState { if m != nil { return m.RegionLocalState } return nil } type RegionSizeRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` Cfs []string `protobuf:"bytes,2,rep,name=cfs" json:"cfs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionSizeRequest) Reset() { *m = RegionSizeRequest{} } func (m *RegionSizeRequest) String() string { return proto.CompactTextString(m) } func (*RegionSizeRequest) ProtoMessage() {} func (*RegionSizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{6} } func (m *RegionSizeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionSizeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionSizeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionSizeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionSizeRequest.Merge(dst, src) } func (m *RegionSizeRequest) XXX_Size() int { return m.Size() } func (m *RegionSizeRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionSizeRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionSizeRequest proto.InternalMessageInfo func (m *RegionSizeRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RegionSizeRequest) GetCfs() []string { if m != nil { return m.Cfs } return nil } type RegionSizeResponse struct { Entries []*RegionSizeResponse_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionSizeResponse) Reset() { *m = RegionSizeResponse{} } func (m *RegionSizeResponse) String() string { return proto.CompactTextString(m) } func (*RegionSizeResponse) ProtoMessage() {} func (*RegionSizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{7} } func (m *RegionSizeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionSizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionSizeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionSizeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionSizeResponse.Merge(dst, src) } func (m *RegionSizeResponse) XXX_Size() int { return m.Size() } func (m *RegionSizeResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionSizeResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionSizeResponse proto.InternalMessageInfo func (m *RegionSizeResponse) GetEntries() []*RegionSizeResponse_Entry { if m != nil { return m.Entries } return nil } type RegionSizeResponse_Entry struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Size_ uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionSizeResponse_Entry) Reset() { *m = RegionSizeResponse_Entry{} } func (m *RegionSizeResponse_Entry) String() string { return proto.CompactTextString(m) } func (*RegionSizeResponse_Entry) ProtoMessage() {} func (*RegionSizeResponse_Entry) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{7, 0} } func (m *RegionSizeResponse_Entry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionSizeResponse_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionSizeResponse_Entry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionSizeResponse_Entry) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionSizeResponse_Entry.Merge(dst, src) } func (m *RegionSizeResponse_Entry) XXX_Size() int { return m.Size() } func (m *RegionSizeResponse_Entry) XXX_DiscardUnknown() { xxx_messageInfo_RegionSizeResponse_Entry.DiscardUnknown(m) } var xxx_messageInfo_RegionSizeResponse_Entry proto.InternalMessageInfo func (m *RegionSizeResponse_Entry) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RegionSizeResponse_Entry) GetSize_() uint64 { if m != nil { return m.Size_ } return 0 } type ScanMvccRequest struct { FromKey []byte `protobuf:"bytes,1,opt,name=from_key,json=fromKey,proto3" json:"from_key,omitempty"` ToKey []byte `protobuf:"bytes,2,opt,name=to_key,json=toKey,proto3" json:"to_key,omitempty"` Limit uint64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanMvccRequest) Reset() { *m = ScanMvccRequest{} } func (m *ScanMvccRequest) String() string { return proto.CompactTextString(m) } func (*ScanMvccRequest) ProtoMessage() {} func (*ScanMvccRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{8} } func (m *ScanMvccRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanMvccRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanMvccRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanMvccRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanMvccRequest.Merge(dst, src) } func (m *ScanMvccRequest) XXX_Size() int { return m.Size() } func (m *ScanMvccRequest) XXX_DiscardUnknown() { xxx_messageInfo_ScanMvccRequest.DiscardUnknown(m) } var xxx_messageInfo_ScanMvccRequest proto.InternalMessageInfo func (m *ScanMvccRequest) GetFromKey() []byte { if m != nil { return m.FromKey } return nil } func (m *ScanMvccRequest) GetToKey() []byte { if m != nil { return m.ToKey } return nil } func (m *ScanMvccRequest) GetLimit() uint64 { if m != nil { return m.Limit } return 0 } type ScanMvccResponse struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Info *kvrpcpb.MvccInfo `protobuf:"bytes,2,opt,name=info" json:"info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanMvccResponse) Reset() { *m = ScanMvccResponse{} } func (m *ScanMvccResponse) String() string { return proto.CompactTextString(m) } func (*ScanMvccResponse) ProtoMessage() {} func (*ScanMvccResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{9} } func (m *ScanMvccResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanMvccResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanMvccResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanMvccResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanMvccResponse.Merge(dst, src) } func (m *ScanMvccResponse) XXX_Size() int { return m.Size() } func (m *ScanMvccResponse) XXX_DiscardUnknown() { xxx_messageInfo_ScanMvccResponse.DiscardUnknown(m) } var xxx_messageInfo_ScanMvccResponse proto.InternalMessageInfo func (m *ScanMvccResponse) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *ScanMvccResponse) GetInfo() *kvrpcpb.MvccInfo { if m != nil { return m.Info } return nil } type CompactRequest struct { Db DB `protobuf:"varint,1,opt,name=db,proto3,enum=debugpb.DB" json:"db,omitempty"` Cf string `protobuf:"bytes,2,opt,name=cf,proto3" json:"cf,omitempty"` FromKey []byte `protobuf:"bytes,3,opt,name=from_key,json=fromKey,proto3" json:"from_key,omitempty"` ToKey []byte `protobuf:"bytes,4,opt,name=to_key,json=toKey,proto3" json:"to_key,omitempty"` Threads uint32 `protobuf:"varint,5,opt,name=threads,proto3" json:"threads,omitempty"` BottommostLevelCompaction BottommostLevelCompaction `protobuf:"varint,6,opt,name=bottommost_level_compaction,json=bottommostLevelCompaction,proto3,enum=debugpb.BottommostLevelCompaction" json:"bottommost_level_compaction,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactRequest) Reset() { *m = CompactRequest{} } func (m *CompactRequest) String() string { return proto.CompactTextString(m) } func (*CompactRequest) ProtoMessage() {} func (*CompactRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{10} } func (m *CompactRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactRequest.Merge(dst, src) } func (m *CompactRequest) XXX_Size() int { return m.Size() } func (m *CompactRequest) XXX_DiscardUnknown() { xxx_messageInfo_CompactRequest.DiscardUnknown(m) } var xxx_messageInfo_CompactRequest proto.InternalMessageInfo func (m *CompactRequest) GetDb() DB { if m != nil { return m.Db } return DB_INVALID } func (m *CompactRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *CompactRequest) GetFromKey() []byte { if m != nil { return m.FromKey } return nil } func (m *CompactRequest) GetToKey() []byte { if m != nil { return m.ToKey } return nil } func (m *CompactRequest) GetThreads() uint32 { if m != nil { return m.Threads } return 0 } func (m *CompactRequest) GetBottommostLevelCompaction() BottommostLevelCompaction { if m != nil { return m.BottommostLevelCompaction } return BottommostLevelCompaction_Skip } type CompactResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactResponse) Reset() { *m = CompactResponse{} } func (m *CompactResponse) String() string { return proto.CompactTextString(m) } func (*CompactResponse) ProtoMessage() {} func (*CompactResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{11} } func (m *CompactResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactResponse.Merge(dst, src) } func (m *CompactResponse) XXX_Size() int { return m.Size() } func (m *CompactResponse) XXX_DiscardUnknown() { xxx_messageInfo_CompactResponse.DiscardUnknown(m) } var xxx_messageInfo_CompactResponse proto.InternalMessageInfo type InjectFailPointRequest struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Actions string `protobuf:"bytes,2,opt,name=actions,proto3" json:"actions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *InjectFailPointRequest) Reset() { *m = InjectFailPointRequest{} } func (m *InjectFailPointRequest) String() string { return proto.CompactTextString(m) } func (*InjectFailPointRequest) ProtoMessage() {} func (*InjectFailPointRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{12} } func (m *InjectFailPointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *InjectFailPointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_InjectFailPointRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *InjectFailPointRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_InjectFailPointRequest.Merge(dst, src) } func (m *InjectFailPointRequest) XXX_Size() int { return m.Size() } func (m *InjectFailPointRequest) XXX_DiscardUnknown() { xxx_messageInfo_InjectFailPointRequest.DiscardUnknown(m) } var xxx_messageInfo_InjectFailPointRequest proto.InternalMessageInfo func (m *InjectFailPointRequest) GetName() string { if m != nil { return m.Name } return "" } func (m *InjectFailPointRequest) GetActions() string { if m != nil { return m.Actions } return "" } type InjectFailPointResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *InjectFailPointResponse) Reset() { *m = InjectFailPointResponse{} } func (m *InjectFailPointResponse) String() string { return proto.CompactTextString(m) } func (*InjectFailPointResponse) ProtoMessage() {} func (*InjectFailPointResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{13} } func (m *InjectFailPointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *InjectFailPointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_InjectFailPointResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *InjectFailPointResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_InjectFailPointResponse.Merge(dst, src) } func (m *InjectFailPointResponse) XXX_Size() int { return m.Size() } func (m *InjectFailPointResponse) XXX_DiscardUnknown() { xxx_messageInfo_InjectFailPointResponse.DiscardUnknown(m) } var xxx_messageInfo_InjectFailPointResponse proto.InternalMessageInfo type RecoverFailPointRequest 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 *RecoverFailPointRequest) Reset() { *m = RecoverFailPointRequest{} } func (m *RecoverFailPointRequest) String() string { return proto.CompactTextString(m) } func (*RecoverFailPointRequest) ProtoMessage() {} func (*RecoverFailPointRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{14} } func (m *RecoverFailPointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RecoverFailPointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RecoverFailPointRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RecoverFailPointRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RecoverFailPointRequest.Merge(dst, src) } func (m *RecoverFailPointRequest) XXX_Size() int { return m.Size() } func (m *RecoverFailPointRequest) XXX_DiscardUnknown() { xxx_messageInfo_RecoverFailPointRequest.DiscardUnknown(m) } var xxx_messageInfo_RecoverFailPointRequest proto.InternalMessageInfo func (m *RecoverFailPointRequest) GetName() string { if m != nil { return m.Name } return "" } type RecoverFailPointResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RecoverFailPointResponse) Reset() { *m = RecoverFailPointResponse{} } func (m *RecoverFailPointResponse) String() string { return proto.CompactTextString(m) } func (*RecoverFailPointResponse) ProtoMessage() {} func (*RecoverFailPointResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{15} } func (m *RecoverFailPointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RecoverFailPointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RecoverFailPointResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RecoverFailPointResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RecoverFailPointResponse.Merge(dst, src) } func (m *RecoverFailPointResponse) XXX_Size() int { return m.Size() } func (m *RecoverFailPointResponse) XXX_DiscardUnknown() { xxx_messageInfo_RecoverFailPointResponse.DiscardUnknown(m) } var xxx_messageInfo_RecoverFailPointResponse proto.InternalMessageInfo type ListFailPointsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListFailPointsRequest) Reset() { *m = ListFailPointsRequest{} } func (m *ListFailPointsRequest) String() string { return proto.CompactTextString(m) } func (*ListFailPointsRequest) ProtoMessage() {} func (*ListFailPointsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{16} } func (m *ListFailPointsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListFailPointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListFailPointsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ListFailPointsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListFailPointsRequest.Merge(dst, src) } func (m *ListFailPointsRequest) XXX_Size() int { return m.Size() } func (m *ListFailPointsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListFailPointsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListFailPointsRequest proto.InternalMessageInfo type ListFailPointsResponse struct { Entries []*ListFailPointsResponse_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListFailPointsResponse) Reset() { *m = ListFailPointsResponse{} } func (m *ListFailPointsResponse) String() string { return proto.CompactTextString(m) } func (*ListFailPointsResponse) ProtoMessage() {} func (*ListFailPointsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{17} } func (m *ListFailPointsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListFailPointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListFailPointsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ListFailPointsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListFailPointsResponse.Merge(dst, src) } func (m *ListFailPointsResponse) XXX_Size() int { return m.Size() } func (m *ListFailPointsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListFailPointsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListFailPointsResponse proto.InternalMessageInfo func (m *ListFailPointsResponse) GetEntries() []*ListFailPointsResponse_Entry { if m != nil { return m.Entries } return nil } type ListFailPointsResponse_Entry struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Actions string `protobuf:"bytes,2,opt,name=actions,proto3" json:"actions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListFailPointsResponse_Entry) Reset() { *m = ListFailPointsResponse_Entry{} } func (m *ListFailPointsResponse_Entry) String() string { return proto.CompactTextString(m) } func (*ListFailPointsResponse_Entry) ProtoMessage() {} func (*ListFailPointsResponse_Entry) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{17, 0} } func (m *ListFailPointsResponse_Entry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListFailPointsResponse_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListFailPointsResponse_Entry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ListFailPointsResponse_Entry) XXX_Merge(src proto.Message) { xxx_messageInfo_ListFailPointsResponse_Entry.Merge(dst, src) } func (m *ListFailPointsResponse_Entry) XXX_Size() int { return m.Size() } func (m *ListFailPointsResponse_Entry) XXX_DiscardUnknown() { xxx_messageInfo_ListFailPointsResponse_Entry.DiscardUnknown(m) } var xxx_messageInfo_ListFailPointsResponse_Entry proto.InternalMessageInfo func (m *ListFailPointsResponse_Entry) GetName() string { if m != nil { return m.Name } return "" } func (m *ListFailPointsResponse_Entry) GetActions() string { if m != nil { return m.Actions } return "" } type GetMetricsRequest struct { All bool `protobuf:"varint,1,opt,name=all,proto3" json:"all,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMetricsRequest) Reset() { *m = GetMetricsRequest{} } func (m *GetMetricsRequest) String() string { return proto.CompactTextString(m) } func (*GetMetricsRequest) ProtoMessage() {} func (*GetMetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{18} } func (m *GetMetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMetricsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMetricsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMetricsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMetricsRequest.Merge(dst, src) } func (m *GetMetricsRequest) XXX_Size() int { return m.Size() } func (m *GetMetricsRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetMetricsRequest.DiscardUnknown(m) } var xxx_messageInfo_GetMetricsRequest proto.InternalMessageInfo func (m *GetMetricsRequest) GetAll() bool { if m != nil { return m.All } return false } type GetMetricsResponse struct { Prometheus string `protobuf:"bytes,1,opt,name=prometheus,proto3" json:"prometheus,omitempty"` RocksdbKv string `protobuf:"bytes,2,opt,name=rocksdb_kv,json=rocksdbKv,proto3" json:"rocksdb_kv,omitempty"` RocksdbRaft string `protobuf:"bytes,3,opt,name=rocksdb_raft,json=rocksdbRaft,proto3" json:"rocksdb_raft,omitempty"` Jemalloc string `protobuf:"bytes,4,opt,name=jemalloc,proto3" json:"jemalloc,omitempty"` StoreId uint64 `protobuf:"varint,5,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMetricsResponse) Reset() { *m = GetMetricsResponse{} } func (m *GetMetricsResponse) String() string { return proto.CompactTextString(m) } func (*GetMetricsResponse) ProtoMessage() {} func (*GetMetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{19} } func (m *GetMetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMetricsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMetricsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMetricsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMetricsResponse.Merge(dst, src) } func (m *GetMetricsResponse) XXX_Size() int { return m.Size() } func (m *GetMetricsResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetMetricsResponse.DiscardUnknown(m) } var xxx_messageInfo_GetMetricsResponse proto.InternalMessageInfo func (m *GetMetricsResponse) GetPrometheus() string { if m != nil { return m.Prometheus } return "" } func (m *GetMetricsResponse) GetRocksdbKv() string { if m != nil { return m.RocksdbKv } return "" } func (m *GetMetricsResponse) GetRocksdbRaft() string { if m != nil { return m.RocksdbRaft } return "" } func (m *GetMetricsResponse) GetJemalloc() string { if m != nil { return m.Jemalloc } return "" } func (m *GetMetricsResponse) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } type RegionConsistencyCheckRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionConsistencyCheckRequest) Reset() { *m = RegionConsistencyCheckRequest{} } func (m *RegionConsistencyCheckRequest) String() string { return proto.CompactTextString(m) } func (*RegionConsistencyCheckRequest) ProtoMessage() {} func (*RegionConsistencyCheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{20} } func (m *RegionConsistencyCheckRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionConsistencyCheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionConsistencyCheckRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionConsistencyCheckRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionConsistencyCheckRequest.Merge(dst, src) } func (m *RegionConsistencyCheckRequest) XXX_Size() int { return m.Size() } func (m *RegionConsistencyCheckRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionConsistencyCheckRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionConsistencyCheckRequest proto.InternalMessageInfo func (m *RegionConsistencyCheckRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type RegionConsistencyCheckResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionConsistencyCheckResponse) Reset() { *m = RegionConsistencyCheckResponse{} } func (m *RegionConsistencyCheckResponse) String() string { return proto.CompactTextString(m) } func (*RegionConsistencyCheckResponse) ProtoMessage() {} func (*RegionConsistencyCheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{21} } func (m *RegionConsistencyCheckResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionConsistencyCheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionConsistencyCheckResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionConsistencyCheckResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionConsistencyCheckResponse.Merge(dst, src) } func (m *RegionConsistencyCheckResponse) XXX_Size() int { return m.Size() } func (m *RegionConsistencyCheckResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionConsistencyCheckResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionConsistencyCheckResponse proto.InternalMessageInfo type ModifyTikvConfigRequest struct { Module MODULE `protobuf:"varint,1,opt,name=module,proto3,enum=debugpb.MODULE" json:"module,omitempty"` ConfigName string `protobuf:"bytes,2,opt,name=config_name,json=configName,proto3" json:"config_name,omitempty"` ConfigValue string `protobuf:"bytes,3,opt,name=config_value,json=configValue,proto3" json:"config_value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ModifyTikvConfigRequest) Reset() { *m = ModifyTikvConfigRequest{} } func (m *ModifyTikvConfigRequest) String() string { return proto.CompactTextString(m) } func (*ModifyTikvConfigRequest) ProtoMessage() {} func (*ModifyTikvConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{22} } func (m *ModifyTikvConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ModifyTikvConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ModifyTikvConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ModifyTikvConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ModifyTikvConfigRequest.Merge(dst, src) } func (m *ModifyTikvConfigRequest) XXX_Size() int { return m.Size() } func (m *ModifyTikvConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_ModifyTikvConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_ModifyTikvConfigRequest proto.InternalMessageInfo func (m *ModifyTikvConfigRequest) GetModule() MODULE { if m != nil { return m.Module } return MODULE_UNUSED } func (m *ModifyTikvConfigRequest) GetConfigName() string { if m != nil { return m.ConfigName } return "" } func (m *ModifyTikvConfigRequest) GetConfigValue() string { if m != nil { return m.ConfigValue } return "" } type ModifyTikvConfigResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ModifyTikvConfigResponse) Reset() { *m = ModifyTikvConfigResponse{} } func (m *ModifyTikvConfigResponse) String() string { return proto.CompactTextString(m) } func (*ModifyTikvConfigResponse) ProtoMessage() {} func (*ModifyTikvConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{23} } func (m *ModifyTikvConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ModifyTikvConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ModifyTikvConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ModifyTikvConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ModifyTikvConfigResponse.Merge(dst, src) } func (m *ModifyTikvConfigResponse) XXX_Size() int { return m.Size() } func (m *ModifyTikvConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_ModifyTikvConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_ModifyTikvConfigResponse proto.InternalMessageInfo type Property struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Property) Reset() { *m = Property{} } func (m *Property) String() string { return proto.CompactTextString(m) } func (*Property) ProtoMessage() {} func (*Property) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{24} } func (m *Property) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Property.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Property) XXX_Merge(src proto.Message) { xxx_messageInfo_Property.Merge(dst, src) } func (m *Property) XXX_Size() int { return m.Size() } func (m *Property) XXX_DiscardUnknown() { xxx_messageInfo_Property.DiscardUnknown(m) } var xxx_messageInfo_Property proto.InternalMessageInfo func (m *Property) GetName() string { if m != nil { return m.Name } return "" } func (m *Property) GetValue() string { if m != nil { return m.Value } return "" } type GetRegionPropertiesRequest struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRegionPropertiesRequest) Reset() { *m = GetRegionPropertiesRequest{} } func (m *GetRegionPropertiesRequest) String() string { return proto.CompactTextString(m) } func (*GetRegionPropertiesRequest) ProtoMessage() {} func (*GetRegionPropertiesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{25} } func (m *GetRegionPropertiesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRegionPropertiesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRegionPropertiesRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRegionPropertiesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRegionPropertiesRequest.Merge(dst, src) } func (m *GetRegionPropertiesRequest) XXX_Size() int { return m.Size() } func (m *GetRegionPropertiesRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetRegionPropertiesRequest.DiscardUnknown(m) } var xxx_messageInfo_GetRegionPropertiesRequest proto.InternalMessageInfo func (m *GetRegionPropertiesRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type GetRegionPropertiesResponse struct { Props []*Property `protobuf:"bytes,1,rep,name=props" json:"props,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRegionPropertiesResponse) Reset() { *m = GetRegionPropertiesResponse{} } func (m *GetRegionPropertiesResponse) String() string { return proto.CompactTextString(m) } func (*GetRegionPropertiesResponse) ProtoMessage() {} func (*GetRegionPropertiesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{26} } func (m *GetRegionPropertiesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRegionPropertiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRegionPropertiesResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRegionPropertiesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRegionPropertiesResponse.Merge(dst, src) } func (m *GetRegionPropertiesResponse) XXX_Size() int { return m.Size() } func (m *GetRegionPropertiesResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetRegionPropertiesResponse.DiscardUnknown(m) } var xxx_messageInfo_GetRegionPropertiesResponse proto.InternalMessageInfo func (m *GetRegionPropertiesResponse) GetProps() []*Property { if m != nil { return m.Props } return nil } type GetStoreInfoRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetStoreInfoRequest) Reset() { *m = GetStoreInfoRequest{} } func (m *GetStoreInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetStoreInfoRequest) ProtoMessage() {} func (*GetStoreInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{27} } func (m *GetStoreInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetStoreInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetStoreInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetStoreInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetStoreInfoRequest.Merge(dst, src) } func (m *GetStoreInfoRequest) XXX_Size() int { return m.Size() } func (m *GetStoreInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetStoreInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_GetStoreInfoRequest proto.InternalMessageInfo type GetStoreInfoResponse struct { StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` ApiVersion kvrpcpb.APIVersion `protobuf:"varint,2,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetStoreInfoResponse) Reset() { *m = GetStoreInfoResponse{} } func (m *GetStoreInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetStoreInfoResponse) ProtoMessage() {} func (*GetStoreInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{28} } func (m *GetStoreInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetStoreInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetStoreInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetStoreInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetStoreInfoResponse.Merge(dst, src) } func (m *GetStoreInfoResponse) XXX_Size() int { return m.Size() } func (m *GetStoreInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetStoreInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_GetStoreInfoResponse proto.InternalMessageInfo func (m *GetStoreInfoResponse) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } func (m *GetStoreInfoResponse) GetApiVersion() kvrpcpb.APIVersion { if m != nil { return m.ApiVersion } return kvrpcpb.APIVersion_V1 } type GetClusterInfoRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetClusterInfoRequest) Reset() { *m = GetClusterInfoRequest{} } func (m *GetClusterInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetClusterInfoRequest) ProtoMessage() {} func (*GetClusterInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{29} } func (m *GetClusterInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetClusterInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetClusterInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetClusterInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetClusterInfoRequest.Merge(dst, src) } func (m *GetClusterInfoRequest) XXX_Size() int { return m.Size() } func (m *GetClusterInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetClusterInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_GetClusterInfoRequest proto.InternalMessageInfo type GetClusterInfoResponse struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetClusterInfoResponse) Reset() { *m = GetClusterInfoResponse{} } func (m *GetClusterInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetClusterInfoResponse) ProtoMessage() {} func (*GetClusterInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{30} } func (m *GetClusterInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetClusterInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetClusterInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetClusterInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetClusterInfoResponse.Merge(dst, src) } func (m *GetClusterInfoResponse) XXX_Size() int { return m.Size() } func (m *GetClusterInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetClusterInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_GetClusterInfoResponse proto.InternalMessageInfo func (m *GetClusterInfoResponse) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } type GetAllRegionsInStoreRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllRegionsInStoreRequest) Reset() { *m = GetAllRegionsInStoreRequest{} } func (m *GetAllRegionsInStoreRequest) String() string { return proto.CompactTextString(m) } func (*GetAllRegionsInStoreRequest) ProtoMessage() {} func (*GetAllRegionsInStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{31} } func (m *GetAllRegionsInStoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllRegionsInStoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllRegionsInStoreRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllRegionsInStoreRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllRegionsInStoreRequest.Merge(dst, src) } func (m *GetAllRegionsInStoreRequest) XXX_Size() int { return m.Size() } func (m *GetAllRegionsInStoreRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetAllRegionsInStoreRequest.DiscardUnknown(m) } var xxx_messageInfo_GetAllRegionsInStoreRequest proto.InternalMessageInfo type GetAllRegionsInStoreResponse struct { Regions []uint64 `protobuf:"varint,1,rep,packed,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllRegionsInStoreResponse) Reset() { *m = GetAllRegionsInStoreResponse{} } func (m *GetAllRegionsInStoreResponse) String() string { return proto.CompactTextString(m) } func (*GetAllRegionsInStoreResponse) ProtoMessage() {} func (*GetAllRegionsInStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{32} } func (m *GetAllRegionsInStoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllRegionsInStoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllRegionsInStoreResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllRegionsInStoreResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllRegionsInStoreResponse.Merge(dst, src) } func (m *GetAllRegionsInStoreResponse) XXX_Size() int { return m.Size() } func (m *GetAllRegionsInStoreResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetAllRegionsInStoreResponse.DiscardUnknown(m) } var xxx_messageInfo_GetAllRegionsInStoreResponse proto.InternalMessageInfo func (m *GetAllRegionsInStoreResponse) GetRegions() []uint64 { if m != nil { return m.Regions } return nil } type ResetToVersionRequest struct { Ts uint64 `protobuf:"varint,1,opt,name=ts,proto3" json:"ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResetToVersionRequest) Reset() { *m = ResetToVersionRequest{} } func (m *ResetToVersionRequest) String() string { return proto.CompactTextString(m) } func (*ResetToVersionRequest) ProtoMessage() {} func (*ResetToVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{33} } func (m *ResetToVersionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResetToVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResetToVersionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResetToVersionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ResetToVersionRequest.Merge(dst, src) } func (m *ResetToVersionRequest) XXX_Size() int { return m.Size() } func (m *ResetToVersionRequest) XXX_DiscardUnknown() { xxx_messageInfo_ResetToVersionRequest.DiscardUnknown(m) } var xxx_messageInfo_ResetToVersionRequest proto.InternalMessageInfo func (m *ResetToVersionRequest) GetTs() uint64 { if m != nil { return m.Ts } return 0 } type ResetToVersionResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResetToVersionResponse) Reset() { *m = ResetToVersionResponse{} } func (m *ResetToVersionResponse) String() string { return proto.CompactTextString(m) } func (*ResetToVersionResponse) ProtoMessage() {} func (*ResetToVersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_debugpb_83d20a1866b48dab, []int{34} } func (m *ResetToVersionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResetToVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResetToVersionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResetToVersionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ResetToVersionResponse.Merge(dst, src) } func (m *ResetToVersionResponse) XXX_Size() int { return m.Size() } func (m *ResetToVersionResponse) XXX_DiscardUnknown() { xxx_messageInfo_ResetToVersionResponse.DiscardUnknown(m) } var xxx_messageInfo_ResetToVersionResponse proto.InternalMessageInfo func init() { proto.RegisterType((*GetRequest)(nil), "debugpb.GetRequest") proto.RegisterType((*GetResponse)(nil), "debugpb.GetResponse") proto.RegisterType((*RaftLogRequest)(nil), "debugpb.RaftLogRequest") proto.RegisterType((*RaftLogResponse)(nil), "debugpb.RaftLogResponse") proto.RegisterType((*RegionInfoRequest)(nil), "debugpb.RegionInfoRequest") proto.RegisterType((*RegionInfoResponse)(nil), "debugpb.RegionInfoResponse") proto.RegisterType((*RegionSizeRequest)(nil), "debugpb.RegionSizeRequest") proto.RegisterType((*RegionSizeResponse)(nil), "debugpb.RegionSizeResponse") proto.RegisterType((*RegionSizeResponse_Entry)(nil), "debugpb.RegionSizeResponse.Entry") proto.RegisterType((*ScanMvccRequest)(nil), "debugpb.ScanMvccRequest") proto.RegisterType((*ScanMvccResponse)(nil), "debugpb.ScanMvccResponse") proto.RegisterType((*CompactRequest)(nil), "debugpb.CompactRequest") proto.RegisterType((*CompactResponse)(nil), "debugpb.CompactResponse") proto.RegisterType((*InjectFailPointRequest)(nil), "debugpb.InjectFailPointRequest") proto.RegisterType((*InjectFailPointResponse)(nil), "debugpb.InjectFailPointResponse") proto.RegisterType((*RecoverFailPointRequest)(nil), "debugpb.RecoverFailPointRequest") proto.RegisterType((*RecoverFailPointResponse)(nil), "debugpb.RecoverFailPointResponse") proto.RegisterType((*ListFailPointsRequest)(nil), "debugpb.ListFailPointsRequest") proto.RegisterType((*ListFailPointsResponse)(nil), "debugpb.ListFailPointsResponse") proto.RegisterType((*ListFailPointsResponse_Entry)(nil), "debugpb.ListFailPointsResponse.Entry") proto.RegisterType((*GetMetricsRequest)(nil), "debugpb.GetMetricsRequest") proto.RegisterType((*GetMetricsResponse)(nil), "debugpb.GetMetricsResponse") proto.RegisterType((*RegionConsistencyCheckRequest)(nil), "debugpb.RegionConsistencyCheckRequest") proto.RegisterType((*RegionConsistencyCheckResponse)(nil), "debugpb.RegionConsistencyCheckResponse") proto.RegisterType((*ModifyTikvConfigRequest)(nil), "debugpb.ModifyTikvConfigRequest") proto.RegisterType((*ModifyTikvConfigResponse)(nil), "debugpb.ModifyTikvConfigResponse") proto.RegisterType((*Property)(nil), "debugpb.Property") proto.RegisterType((*GetRegionPropertiesRequest)(nil), "debugpb.GetRegionPropertiesRequest") proto.RegisterType((*GetRegionPropertiesResponse)(nil), "debugpb.GetRegionPropertiesResponse") proto.RegisterType((*GetStoreInfoRequest)(nil), "debugpb.GetStoreInfoRequest") proto.RegisterType((*GetStoreInfoResponse)(nil), "debugpb.GetStoreInfoResponse") proto.RegisterType((*GetClusterInfoRequest)(nil), "debugpb.GetClusterInfoRequest") proto.RegisterType((*GetClusterInfoResponse)(nil), "debugpb.GetClusterInfoResponse") proto.RegisterType((*GetAllRegionsInStoreRequest)(nil), "debugpb.GetAllRegionsInStoreRequest") proto.RegisterType((*GetAllRegionsInStoreResponse)(nil), "debugpb.GetAllRegionsInStoreResponse") proto.RegisterType((*ResetToVersionRequest)(nil), "debugpb.ResetToVersionRequest") proto.RegisterType((*ResetToVersionResponse)(nil), "debugpb.ResetToVersionResponse") proto.RegisterEnum("debugpb.DB", DB_name, DB_value) proto.RegisterEnum("debugpb.MODULE", MODULE_name, MODULE_value) proto.RegisterEnum("debugpb.BottommostLevelCompaction", BottommostLevelCompaction_name, BottommostLevelCompaction_value) } // 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 // Client API for Debug service type DebugClient interface { // Read a value arbitrarily for a key. // Note: Server uses key directly w/o any encoding. Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) // Read raft info. RaftLog(ctx context.Context, in *RaftLogRequest, opts ...grpc.CallOption) (*RaftLogResponse, error) RegionInfo(ctx context.Context, in *RegionInfoRequest, opts ...grpc.CallOption) (*RegionInfoResponse, error) // Calculate size of a region. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. RegionSize(ctx context.Context, in *RegionSizeRequest, opts ...grpc.CallOption) (*RegionSizeResponse, error) // Scan a specific range. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. // Server uses keys directly w/o any encoding. ScanMvcc(ctx context.Context, in *ScanMvccRequest, opts ...grpc.CallOption) (Debug_ScanMvccClient, error) // Compact a column family in a specified range. // Note: Server uses keys directly w/o any encoding. Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) // Inject a fail point. Currently, it's only used in tests. // Note: DO NOT CALL IT IN PRODUCTION. InjectFailPoint(ctx context.Context, in *InjectFailPointRequest, opts ...grpc.CallOption) (*InjectFailPointResponse, error) // Recover from a fail point. RecoverFailPoint(ctx context.Context, in *RecoverFailPointRequest, opts ...grpc.CallOption) (*RecoverFailPointResponse, error) // List all fail points. ListFailPoints(ctx context.Context, in *ListFailPointsRequest, opts ...grpc.CallOption) (*ListFailPointsResponse, error) // Get Metrics GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) // Do a consistent check for a region. CheckRegionConsistency(ctx context.Context, in *RegionConsistencyCheckRequest, opts ...grpc.CallOption) (*RegionConsistencyCheckResponse, error) // dynamically modify tikv's config ModifyTikvConfig(ctx context.Context, in *ModifyTikvConfigRequest, opts ...grpc.CallOption) (*ModifyTikvConfigResponse, error) // Get region properties GetRegionProperties(ctx context.Context, in *GetRegionPropertiesRequest, opts ...grpc.CallOption) (*GetRegionPropertiesResponse, error) // Get store ID GetStoreInfo(ctx context.Context, in *GetStoreInfoRequest, opts ...grpc.CallOption) (*GetStoreInfoResponse, error) // Get cluster ID GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) // Get all region IDs in the store GetAllRegionsInStore(ctx context.Context, in *GetAllRegionsInStoreRequest, opts ...grpc.CallOption) (*GetAllRegionsInStoreResponse, error) // Make this TiKV node return to the status on this node to certain ts. ResetToVersion(ctx context.Context, in *ResetToVersionRequest, opts ...grpc.CallOption) (*ResetToVersionResponse, error) } type debugClient struct { cc *grpc.ClientConn } func NewDebugClient(cc *grpc.ClientConn) DebugClient { return &debugClient{cc} } func (c *debugClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { out := new(GetResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/Get", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) RaftLog(ctx context.Context, in *RaftLogRequest, opts ...grpc.CallOption) (*RaftLogResponse, error) { out := new(RaftLogResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/RaftLog", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) RegionInfo(ctx context.Context, in *RegionInfoRequest, opts ...grpc.CallOption) (*RegionInfoResponse, error) { out := new(RegionInfoResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/RegionInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) RegionSize(ctx context.Context, in *RegionSizeRequest, opts ...grpc.CallOption) (*RegionSizeResponse, error) { out := new(RegionSizeResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/RegionSize", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) ScanMvcc(ctx context.Context, in *ScanMvccRequest, opts ...grpc.CallOption) (Debug_ScanMvccClient, error) { stream, err := c.cc.NewStream(ctx, &_Debug_serviceDesc.Streams[0], "/debugpb.Debug/ScanMvcc", opts...) if err != nil { return nil, err } x := &debugScanMvccClient{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 Debug_ScanMvccClient interface { Recv() (*ScanMvccResponse, error) grpc.ClientStream } type debugScanMvccClient struct { grpc.ClientStream } func (x *debugScanMvccClient) Recv() (*ScanMvccResponse, error) { m := new(ScanMvccResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *debugClient) Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) { out := new(CompactResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/Compact", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) InjectFailPoint(ctx context.Context, in *InjectFailPointRequest, opts ...grpc.CallOption) (*InjectFailPointResponse, error) { out := new(InjectFailPointResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/InjectFailPoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) RecoverFailPoint(ctx context.Context, in *RecoverFailPointRequest, opts ...grpc.CallOption) (*RecoverFailPointResponse, error) { out := new(RecoverFailPointResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/RecoverFailPoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) ListFailPoints(ctx context.Context, in *ListFailPointsRequest, opts ...grpc.CallOption) (*ListFailPointsResponse, error) { out := new(ListFailPointsResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/ListFailPoints", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) { out := new(GetMetricsResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/GetMetrics", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) CheckRegionConsistency(ctx context.Context, in *RegionConsistencyCheckRequest, opts ...grpc.CallOption) (*RegionConsistencyCheckResponse, error) { out := new(RegionConsistencyCheckResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/CheckRegionConsistency", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) ModifyTikvConfig(ctx context.Context, in *ModifyTikvConfigRequest, opts ...grpc.CallOption) (*ModifyTikvConfigResponse, error) { out := new(ModifyTikvConfigResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/ModifyTikvConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) GetRegionProperties(ctx context.Context, in *GetRegionPropertiesRequest, opts ...grpc.CallOption) (*GetRegionPropertiesResponse, error) { out := new(GetRegionPropertiesResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/GetRegionProperties", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) GetStoreInfo(ctx context.Context, in *GetStoreInfoRequest, opts ...grpc.CallOption) (*GetStoreInfoResponse, error) { out := new(GetStoreInfoResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/GetStoreInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) { out := new(GetClusterInfoResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/GetClusterInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) GetAllRegionsInStore(ctx context.Context, in *GetAllRegionsInStoreRequest, opts ...grpc.CallOption) (*GetAllRegionsInStoreResponse, error) { out := new(GetAllRegionsInStoreResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/GetAllRegionsInStore", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *debugClient) ResetToVersion(ctx context.Context, in *ResetToVersionRequest, opts ...grpc.CallOption) (*ResetToVersionResponse, error) { out := new(ResetToVersionResponse) err := c.cc.Invoke(ctx, "/debugpb.Debug/ResetToVersion", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for Debug service type DebugServer interface { // Read a value arbitrarily for a key. // Note: Server uses key directly w/o any encoding. Get(context.Context, *GetRequest) (*GetResponse, error) // Read raft info. RaftLog(context.Context, *RaftLogRequest) (*RaftLogResponse, error) RegionInfo(context.Context, *RegionInfoRequest) (*RegionInfoResponse, error) // Calculate size of a region. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. RegionSize(context.Context, *RegionSizeRequest) (*RegionSizeResponse, error) // Scan a specific range. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. // Server uses keys directly w/o any encoding. ScanMvcc(*ScanMvccRequest, Debug_ScanMvccServer) error // Compact a column family in a specified range. // Note: Server uses keys directly w/o any encoding. Compact(context.Context, *CompactRequest) (*CompactResponse, error) // Inject a fail point. Currently, it's only used in tests. // Note: DO NOT CALL IT IN PRODUCTION. InjectFailPoint(context.Context, *InjectFailPointRequest) (*InjectFailPointResponse, error) // Recover from a fail point. RecoverFailPoint(context.Context, *RecoverFailPointRequest) (*RecoverFailPointResponse, error) // List all fail points. ListFailPoints(context.Context, *ListFailPointsRequest) (*ListFailPointsResponse, error) // Get Metrics GetMetrics(context.Context, *GetMetricsRequest) (*GetMetricsResponse, error) // Do a consistent check for a region. CheckRegionConsistency(context.Context, *RegionConsistencyCheckRequest) (*RegionConsistencyCheckResponse, error) // dynamically modify tikv's config ModifyTikvConfig(context.Context, *ModifyTikvConfigRequest) (*ModifyTikvConfigResponse, error) // Get region properties GetRegionProperties(context.Context, *GetRegionPropertiesRequest) (*GetRegionPropertiesResponse, error) // Get store ID GetStoreInfo(context.Context, *GetStoreInfoRequest) (*GetStoreInfoResponse, error) // Get cluster ID GetClusterInfo(context.Context, *GetClusterInfoRequest) (*GetClusterInfoResponse, error) // Get all region IDs in the store GetAllRegionsInStore(context.Context, *GetAllRegionsInStoreRequest) (*GetAllRegionsInStoreResponse, error) // Make this TiKV node return to the status on this node to certain ts. ResetToVersion(context.Context, *ResetToVersionRequest) (*ResetToVersionResponse, error) } func RegisterDebugServer(s *grpc.Server, srv DebugServer) { s.RegisterService(&_Debug_serviceDesc, srv) } func _Debug_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.(DebugServer).Get(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/Get", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).Get(ctx, req.(*GetRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_RaftLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RaftLogRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).RaftLog(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/RaftLog", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).RaftLog(ctx, req.(*RaftLogRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_RegionInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RegionInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).RegionInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/RegionInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).RegionInfo(ctx, req.(*RegionInfoRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_RegionSize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RegionSizeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).RegionSize(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/RegionSize", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).RegionSize(ctx, req.(*RegionSizeRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_ScanMvcc_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ScanMvccRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(DebugServer).ScanMvcc(m, &debugScanMvccServer{stream}) } type Debug_ScanMvccServer interface { Send(*ScanMvccResponse) error grpc.ServerStream } type debugScanMvccServer struct { grpc.ServerStream } func (x *debugScanMvccServer) Send(m *ScanMvccResponse) error { return x.ServerStream.SendMsg(m) } func _Debug_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CompactRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).Compact(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/Compact", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).Compact(ctx, req.(*CompactRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_InjectFailPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(InjectFailPointRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).InjectFailPoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/InjectFailPoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).InjectFailPoint(ctx, req.(*InjectFailPointRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_RecoverFailPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RecoverFailPointRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).RecoverFailPoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/RecoverFailPoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).RecoverFailPoint(ctx, req.(*RecoverFailPointRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_ListFailPoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListFailPointsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).ListFailPoints(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/ListFailPoints", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).ListFailPoints(ctx, req.(*ListFailPointsRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetMetricsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).GetMetrics(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/GetMetrics", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).GetMetrics(ctx, req.(*GetMetricsRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_CheckRegionConsistency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RegionConsistencyCheckRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).CheckRegionConsistency(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/CheckRegionConsistency", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).CheckRegionConsistency(ctx, req.(*RegionConsistencyCheckRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_ModifyTikvConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ModifyTikvConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).ModifyTikvConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/ModifyTikvConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).ModifyTikvConfig(ctx, req.(*ModifyTikvConfigRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_GetRegionProperties_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetRegionPropertiesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).GetRegionProperties(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/GetRegionProperties", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).GetRegionProperties(ctx, req.(*GetRegionPropertiesRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_GetStoreInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetStoreInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).GetStoreInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/GetStoreInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).GetStoreInfo(ctx, req.(*GetStoreInfoRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_GetClusterInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetClusterInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).GetClusterInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/GetClusterInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).GetClusterInfo(ctx, req.(*GetClusterInfoRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_GetAllRegionsInStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetAllRegionsInStoreRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).GetAllRegionsInStore(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/GetAllRegionsInStore", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).GetAllRegionsInStore(ctx, req.(*GetAllRegionsInStoreRequest)) } return interceptor(ctx, in, info, handler) } func _Debug_ResetToVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ResetToVersionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DebugServer).ResetToVersion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/debugpb.Debug/ResetToVersion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DebugServer).ResetToVersion(ctx, req.(*ResetToVersionRequest)) } return interceptor(ctx, in, info, handler) } var _Debug_serviceDesc = grpc.ServiceDesc{ ServiceName: "debugpb.Debug", HandlerType: (*DebugServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Get", Handler: _Debug_Get_Handler, }, { MethodName: "RaftLog", Handler: _Debug_RaftLog_Handler, }, { MethodName: "RegionInfo", Handler: _Debug_RegionInfo_Handler, }, { MethodName: "RegionSize", Handler: _Debug_RegionSize_Handler, }, { MethodName: "Compact", Handler: _Debug_Compact_Handler, }, { MethodName: "InjectFailPoint", Handler: _Debug_InjectFailPoint_Handler, }, { MethodName: "RecoverFailPoint", Handler: _Debug_RecoverFailPoint_Handler, }, { MethodName: "ListFailPoints", Handler: _Debug_ListFailPoints_Handler, }, { MethodName: "GetMetrics", Handler: _Debug_GetMetrics_Handler, }, { MethodName: "CheckRegionConsistency", Handler: _Debug_CheckRegionConsistency_Handler, }, { MethodName: "ModifyTikvConfig", Handler: _Debug_ModifyTikvConfig_Handler, }, { MethodName: "GetRegionProperties", Handler: _Debug_GetRegionProperties_Handler, }, { MethodName: "GetStoreInfo", Handler: _Debug_GetStoreInfo_Handler, }, { MethodName: "GetClusterInfo", Handler: _Debug_GetClusterInfo_Handler, }, { MethodName: "GetAllRegionsInStore", Handler: _Debug_GetAllRegionsInStore_Handler, }, { MethodName: "ResetToVersion", Handler: _Debug_ResetToVersion_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "ScanMvcc", Handler: _Debug_ScanMvcc_Handler, ServerStreams: true, }, }, Metadata: "debugpb.proto", } func (m *GetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Db != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Db)) } if len(m.Cf) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.Key) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Value) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftLogRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftLogRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionId)) } if m.LogIndex != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.LogIndex)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftLogResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftLogResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Entry != nil { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Entry.Size())) n1, err := m.Entry.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RaftLocalState != nil { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RaftLocalState.Size())) n2, err := m.RaftLocalState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.RaftApplyState != nil { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RaftApplyState.Size())) n3, err := m.RaftApplyState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.RegionLocalState != nil { dAtA[i] = 0x1a i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionLocalState.Size())) n4, err := m.RegionLocalState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionSizeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionSizeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionId)) } if len(m.Cfs) > 0 { for _, s := range m.Cfs { dAtA[i] = 0x12 i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionSizeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionSizeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionSizeResponse_Entry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionSizeResponse_Entry) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Size_ != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Size_)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanMvccRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanMvccRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.FromKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.FromKey))) i += copy(dAtA[i:], m.FromKey) } if len(m.ToKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ToKey))) i += copy(dAtA[i:], m.ToKey) } if m.Limit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Limit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanMvccResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanMvccResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Info != nil { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Info.Size())) n5, err := m.Info.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Db != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Db)) } if len(m.Cf) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.FromKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.FromKey))) i += copy(dAtA[i:], m.FromKey) } if len(m.ToKey) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ToKey))) i += copy(dAtA[i:], m.ToKey) } if m.Threads != 0 { dAtA[i] = 0x28 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Threads)) } if m.BottommostLevelCompaction != 0 { dAtA[i] = 0x30 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.BottommostLevelCompaction)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *InjectFailPointRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InjectFailPointRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Actions) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Actions))) i += copy(dAtA[i:], m.Actions) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *InjectFailPointResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *InjectFailPointResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RecoverFailPointRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RecoverFailPointRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RecoverFailPointResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RecoverFailPointResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ListFailPointsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListFailPointsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ListFailPointsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListFailPointsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ListFailPointsResponse_Entry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ListFailPointsResponse_Entry) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Actions) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Actions))) i += copy(dAtA[i:], m.Actions) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMetricsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMetricsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.All { dAtA[i] = 0x8 i++ if m.All { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMetricsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMetricsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Prometheus) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Prometheus))) i += copy(dAtA[i:], m.Prometheus) } if len(m.RocksdbKv) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.RocksdbKv))) i += copy(dAtA[i:], m.RocksdbKv) } if len(m.RocksdbRaft) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.RocksdbRaft))) i += copy(dAtA[i:], m.RocksdbRaft) } if len(m.Jemalloc) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Jemalloc))) i += copy(dAtA[i:], m.Jemalloc) } if m.StoreId != 0 { dAtA[i] = 0x28 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.StoreId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionConsistencyCheckRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionConsistencyCheckRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionConsistencyCheckResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionConsistencyCheckResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ModifyTikvConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ModifyTikvConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Module != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Module)) } if len(m.ConfigName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ConfigName))) i += copy(dAtA[i:], m.ConfigName) } if len(m.ConfigValue) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ConfigValue))) i += copy(dAtA[i:], m.ConfigValue) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ModifyTikvConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ModifyTikvConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Property) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Property) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRegionPropertiesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRegionPropertiesRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRegionPropertiesResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRegionPropertiesResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Props) > 0 { for _, msg := range m.Props { dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetStoreInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetStoreInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetStoreInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetStoreInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StoreId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.StoreId)) } if m.ApiVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetClusterInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetClusterInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetClusterInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetClusterInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.ClusterId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllRegionsInStoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllRegionsInStoreRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllRegionsInStoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllRegionsInStoreResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Regions) > 0 { dAtA7 := make([]byte, len(m.Regions)*10) var j6 int for _, num := range m.Regions { for num >= 1<<7 { dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j6++ } dAtA7[j6] = uint8(num) j6++ } dAtA[i] = 0xa i++ i = encodeVarintDebugpb(dAtA, i, uint64(j6)) i += copy(dAtA[i:], dAtA7[:j6]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResetToVersionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResetToVersionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Ts != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDebugpb(dAtA, i, uint64(m.Ts)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResetToVersionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResetToVersionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintDebugpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *GetRequest) Size() (n int) { var l int _ = l if m.Db != 0 { n += 1 + sovDebugpb(uint64(m.Db)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetResponse) Size() (n int) { var l int _ = l l = len(m.Value) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftLogRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovDebugpb(uint64(m.RegionId)) } if m.LogIndex != 0 { n += 1 + sovDebugpb(uint64(m.LogIndex)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftLogResponse) Size() (n int) { var l int _ = l if m.Entry != nil { l = m.Entry.Size() n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionInfoRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovDebugpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionInfoResponse) Size() (n int) { var l int _ = l if m.RaftLocalState != nil { l = m.RaftLocalState.Size() n += 1 + l + sovDebugpb(uint64(l)) } if m.RaftApplyState != nil { l = m.RaftApplyState.Size() n += 1 + l + sovDebugpb(uint64(l)) } if m.RegionLocalState != nil { l = m.RegionLocalState.Size() n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionSizeRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovDebugpb(uint64(m.RegionId)) } if len(m.Cfs) > 0 { for _, s := range m.Cfs { l = len(s) n += 1 + l + sovDebugpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionSizeResponse) Size() (n int) { var l int _ = l if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovDebugpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionSizeResponse_Entry) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.Size_ != 0 { n += 1 + sovDebugpb(uint64(m.Size_)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanMvccRequest) Size() (n int) { var l int _ = l l = len(m.FromKey) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.ToKey) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovDebugpb(uint64(m.Limit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanMvccResponse) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.Info != nil { l = m.Info.Size() n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactRequest) Size() (n int) { var l int _ = l if m.Db != 0 { n += 1 + sovDebugpb(uint64(m.Db)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.FromKey) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.ToKey) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.Threads != 0 { n += 1 + sovDebugpb(uint64(m.Threads)) } if m.BottommostLevelCompaction != 0 { n += 1 + sovDebugpb(uint64(m.BottommostLevelCompaction)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *InjectFailPointRequest) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.Actions) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *InjectFailPointResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RecoverFailPointRequest) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RecoverFailPointResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListFailPointsRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListFailPointsResponse) Size() (n int) { var l int _ = l if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovDebugpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ListFailPointsResponse_Entry) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.Actions) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMetricsRequest) Size() (n int) { var l int _ = l if m.All { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMetricsResponse) Size() (n int) { var l int _ = l l = len(m.Prometheus) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.RocksdbKv) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.RocksdbRaft) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.Jemalloc) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.StoreId != 0 { n += 1 + sovDebugpb(uint64(m.StoreId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionConsistencyCheckRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovDebugpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionConsistencyCheckResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ModifyTikvConfigRequest) Size() (n int) { var l int _ = l if m.Module != 0 { n += 1 + sovDebugpb(uint64(m.Module)) } l = len(m.ConfigName) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.ConfigValue) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ModifyTikvConfigResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Property) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovDebugpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRegionPropertiesRequest) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovDebugpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRegionPropertiesResponse) Size() (n int) { var l int _ = l if len(m.Props) > 0 { for _, e := range m.Props { l = e.Size() n += 1 + l + sovDebugpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetStoreInfoRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetStoreInfoResponse) Size() (n int) { var l int _ = l if m.StoreId != 0 { n += 1 + sovDebugpb(uint64(m.StoreId)) } if m.ApiVersion != 0 { n += 1 + sovDebugpb(uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetClusterInfoRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetClusterInfoResponse) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovDebugpb(uint64(m.ClusterId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllRegionsInStoreRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllRegionsInStoreResponse) Size() (n int) { var l int _ = l if len(m.Regions) > 0 { l = 0 for _, e := range m.Regions { l += sovDebugpb(uint64(e)) } n += 1 + sovDebugpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResetToVersionRequest) Size() (n int) { var l int _ = l if m.Ts != 0 { n += 1 + sovDebugpb(uint64(m.Ts)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResetToVersionResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovDebugpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozDebugpb(x uint64) (n int) { return sovDebugpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } 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 ErrIntOverflowDebugpb } 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 != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) } m.Db = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Db |= (DB(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 ErrIntOverflowDebugpb } 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 Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RaftLogRequest) 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 ErrIntOverflowDebugpb } 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: RaftLogRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftLogRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LogIndex", wireType) } m.LogIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LogIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RaftLogResponse) 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 ErrIntOverflowDebugpb } 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: RaftLogResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftLogResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Entry == nil { m.Entry = &eraftpb.Entry{} } if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionInfoRequest) 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 ErrIntOverflowDebugpb } 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: RegionInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionInfoResponse) 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 ErrIntOverflowDebugpb } 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: RegionInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RaftLocalState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RaftLocalState == nil { m.RaftLocalState = &raft_serverpb.RaftLocalState{} } if err := m.RaftLocalState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RaftApplyState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RaftApplyState == nil { m.RaftApplyState = &raft_serverpb.RaftApplyState{} } if err := m.RaftApplyState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionLocalState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionLocalState == nil { m.RegionLocalState = &raft_serverpb.RegionLocalState{} } if err := m.RegionLocalState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionSizeRequest) 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 ErrIntOverflowDebugpb } 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: RegionSizeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionSizeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cfs", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cfs = append(m.Cfs, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionSizeResponse) 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 ErrIntOverflowDebugpb } 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: RegionSizeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionSizeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &RegionSizeResponse_Entry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionSizeResponse_Entry) 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 ErrIntOverflowDebugpb } 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: Entry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(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 ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ScanMvccRequest) 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 ErrIntOverflowDebugpb } 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: ScanMvccRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanMvccRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FromKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.FromKey = append(m.FromKey[:0], dAtA[iNdEx:postIndex]...) if m.FromKey == nil { m.FromKey = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ToKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ToKey = append(m.ToKey[:0], dAtA[iNdEx:postIndex]...) if m.ToKey == nil { m.ToKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ScanMvccResponse) 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 ErrIntOverflowDebugpb } 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: ScanMvccResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanMvccResponse: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } 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 ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Info == nil { m.Info = &kvrpcpb.MvccInfo{} } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *CompactRequest) 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 ErrIntOverflowDebugpb } 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: CompactRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) } m.Db = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Db |= (DB(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FromKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.FromKey = append(m.FromKey[:0], dAtA[iNdEx:postIndex]...) if m.FromKey == nil { m.FromKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ToKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ToKey = append(m.ToKey[:0], dAtA[iNdEx:postIndex]...) if m.ToKey == nil { m.ToKey = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Threads", wireType) } m.Threads = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Threads |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BottommostLevelCompaction", wireType) } m.BottommostLevelCompaction = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BottommostLevelCompaction |= (BottommostLevelCompaction(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *CompactResponse) 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 ErrIntOverflowDebugpb } 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: CompactResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *InjectFailPointRequest) 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 ErrIntOverflowDebugpb } 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: InjectFailPointRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InjectFailPointRequest: 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 ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen 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 Actions", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Actions = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *InjectFailPointResponse) 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 ErrIntOverflowDebugpb } 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: InjectFailPointResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: InjectFailPointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RecoverFailPointRequest) 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 ErrIntOverflowDebugpb } 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: RecoverFailPointRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RecoverFailPointRequest: 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 ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RecoverFailPointResponse) 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 ErrIntOverflowDebugpb } 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: RecoverFailPointResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RecoverFailPointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ListFailPointsRequest) 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 ErrIntOverflowDebugpb } 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: ListFailPointsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListFailPointsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ListFailPointsResponse) 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 ErrIntOverflowDebugpb } 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: ListFailPointsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListFailPointsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &ListFailPointsResponse_Entry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ListFailPointsResponse_Entry) 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 ErrIntOverflowDebugpb } 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: Entry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Entry: 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 ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen 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 Actions", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Actions = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetMetricsRequest) 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 ErrIntOverflowDebugpb } 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: GetMetricsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowDebugpb } 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 := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetMetricsResponse) 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 ErrIntOverflowDebugpb } 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: GetMetricsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prometheus", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prometheus = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbKv", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.RocksdbKv = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbRaft", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.RocksdbRaft = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Jemalloc", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Jemalloc = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionConsistencyCheckRequest) 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 ErrIntOverflowDebugpb } 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: RegionConsistencyCheckRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionConsistencyCheckRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *RegionConsistencyCheckResponse) 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 ErrIntOverflowDebugpb } 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: RegionConsistencyCheckResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionConsistencyCheckResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ModifyTikvConfigRequest) 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 ErrIntOverflowDebugpb } 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: ModifyTikvConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ModifyTikvConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType) } m.Module = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Module |= (MODULE(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConfigName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ConfigName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConfigValue", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ConfigValue = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ModifyTikvConfigResponse) 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 ErrIntOverflowDebugpb } 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: ModifyTikvConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ModifyTikvConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *Property) 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 ErrIntOverflowDebugpb } 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: Property: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Property: 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 ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } 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 ErrInvalidLengthDebugpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetRegionPropertiesRequest) 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 ErrIntOverflowDebugpb } 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: GetRegionPropertiesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRegionPropertiesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetRegionPropertiesResponse) 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 ErrIntOverflowDebugpb } 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: GetRegionPropertiesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRegionPropertiesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Props", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Props = append(m.Props, &Property{}) if err := m.Props[len(m.Props)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetStoreInfoRequest) 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 ErrIntOverflowDebugpb } 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: GetStoreInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetStoreInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetStoreInfoResponse) 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 ErrIntOverflowDebugpb } 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: GetStoreInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetStoreInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (kvrpcpb.APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetClusterInfoRequest) 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 ErrIntOverflowDebugpb } 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: GetClusterInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetClusterInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetClusterInfoResponse) 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 ErrIntOverflowDebugpb } 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: GetClusterInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetAllRegionsInStoreRequest) 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 ErrIntOverflowDebugpb } 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: GetAllRegionsInStoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllRegionsInStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *GetAllRegionsInStoreResponse) 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 ErrIntOverflowDebugpb } 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: GetAllRegionsInStoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllRegionsInStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthDebugpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ResetToVersionRequest) 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 ErrIntOverflowDebugpb } 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: ResetToVersionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResetToVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType) } m.Ts = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDebugpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ts |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 *ResetToVersionResponse) 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 ErrIntOverflowDebugpb } 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: ResetToVersionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResetToVersionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipDebugpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDebugpb } 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 skipDebugpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDebugpb } 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, ErrIntOverflowDebugpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDebugpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthDebugpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDebugpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipDebugpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthDebugpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowDebugpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("debugpb.proto", fileDescriptor_debugpb_83d20a1866b48dab) } var fileDescriptor_debugpb_83d20a1866b48dab = []byte{ // 1628 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xcf, 0x73, 0xe2, 0xc8, 0x15, 0x46, 0xe2, 0xf7, 0xc3, 0xc6, 0x72, 0xfb, 0x17, 0x96, 0xd7, 0x36, 0xd6, 0xac, 0xd7, 0xae, 0x49, 0xc5, 0xd9, 0x72, 0x36, 0xb5, 0x49, 0x25, 0x95, 0x94, 0x0d, 0x98, 0x10, 0x9b, 0xc1, 0xd5, 0xd8, 0xae, 0x9a, 0x13, 0x25, 0x44, 0xc3, 0x68, 0x11, 0x34, 0x91, 0xda, 0x54, 0xbc, 0x87, 0x1c, 0x73, 0xde, 0x63, 0xfe, 0x84, 0x5c, 0xf2, 0x7f, 0xe4, 0x98, 0x63, 0x8e, 0xa9, 0xc9, 0x39, 0x95, 0x53, 0xee, 0xa9, 0x6e, 0xb5, 0x84, 0x10, 0xb0, 0xe3, 0xec, 0x89, 0xee, 0xf7, 0x5e, 0x7f, 0xfd, 0xfa, 0xbd, 0xaf, 0xf5, 0x75, 0x01, 0xeb, 0x3d, 0xd2, 0x7d, 0x1e, 0x4c, 0xba, 0x17, 0x13, 0x97, 0x32, 0x8a, 0xb2, 0x72, 0xaa, 0xaf, 0x13, 0xd7, 0xec, 0xb3, 0xc0, 0xae, 0xaf, 0x0f, 0xa7, 0xee, 0xc4, 0x0a, 0xa7, 0x5b, 0xdc, 0xd9, 0xf1, 0x88, 0x3b, 0x25, 0x6e, 0x68, 0xdc, 0x1e, 0xd0, 0x01, 0x15, 0xc3, 0x9f, 0xf0, 0x91, 0xb4, 0x6e, 0xb8, 0xcf, 0x1e, 0x13, 0x43, 0xdf, 0x60, 0xdc, 0x02, 0xd4, 0x09, 0xc3, 0xe4, 0xf7, 0xcf, 0xc4, 0x63, 0xe8, 0x00, 0xd4, 0x5e, 0xb7, 0xa4, 0x94, 0x95, 0xf3, 0xe2, 0x65, 0xe1, 0x22, 0x48, 0xa6, 0x7a, 0x8d, 0xd5, 0x5e, 0x17, 0x15, 0x41, 0xb5, 0xfa, 0x25, 0xb5, 0xac, 0x9c, 0xe7, 0xb1, 0x6a, 0xf5, 0x91, 0x06, 0xc9, 0x21, 0x79, 0x29, 0x25, 0xcb, 0xca, 0xf9, 0x1a, 0xe6, 0x43, 0xe3, 0x0d, 0x14, 0x04, 0x98, 0x37, 0xa1, 0x63, 0x8f, 0xa0, 0x6d, 0x48, 0x4f, 0x4d, 0xe7, 0x99, 0x08, 0xc0, 0x35, 0xec, 0x4f, 0x8c, 0xdf, 0x41, 0x11, 0x9b, 0x7d, 0x76, 0x47, 0x07, 0xb3, 0x5d, 0xf3, 0x2e, 0x19, 0xd8, 0x74, 0xdc, 0xb1, 0x7b, 0x22, 0x36, 0x85, 0x73, 0xbe, 0xa1, 0xd1, 0xe3, 0x4e, 0x87, 0x0e, 0x3a, 0xf6, 0xb8, 0x47, 0xfe, 0x20, 0x36, 0x4f, 0xe1, 0x9c, 0x43, 0x07, 0x0d, 0x3e, 0x37, 0xbe, 0x86, 0x8d, 0x10, 0x4b, 0x6e, 0xfa, 0x39, 0xa4, 0xc9, 0x98, 0xb9, 0x2f, 0x02, 0xa8, 0x70, 0x59, 0xbc, 0x08, 0x4a, 0x57, 0xe3, 0x56, 0xec, 0x3b, 0x8d, 0x2f, 0x61, 0x13, 0xfb, 0x3b, 0x8c, 0xfb, 0xf4, 0x35, 0x79, 0x18, 0xff, 0x55, 0x00, 0x45, 0x97, 0xc8, 0xed, 0xea, 0xa0, 0x89, 0xea, 0x3b, 0xd4, 0x32, 0x9d, 0x8e, 0xc7, 0x4c, 0x46, 0xe4, 0xce, 0x87, 0x17, 0xf3, 0x6d, 0xf1, 0x13, 0xb5, 0x4c, 0xa7, 0xcd, 0x83, 0x70, 0xd1, 0x9d, 0x9b, 0x87, 0x40, 0xe6, 0x64, 0xe2, 0xbc, 0x48, 0x20, 0x75, 0x25, 0xd0, 0x15, 0x8f, 0x8a, 0x00, 0xcd, 0xe6, 0xa8, 0x09, 0x48, 0x9e, 0x22, 0x9a, 0x53, 0x52, 0x40, 0x1d, 0xc7, 0xa1, 0x44, 0x60, 0x24, 0x2b, 0xcd, 0x8d, 0x59, 0x8c, 0xeb, 0xa0, 0x52, 0x6d, 0xfb, 0x5b, 0xf2, 0xaa, 0x8e, 0x69, 0x90, 0xb4, 0xfa, 0x5e, 0x49, 0x2d, 0x27, 0xcf, 0xf3, 0x98, 0x0f, 0x8d, 0x3f, 0x06, 0xa5, 0xf3, 0x31, 0x64, 0xe9, 0x7e, 0x09, 0x59, 0xde, 0x0c, 0x9b, 0x78, 0x25, 0xa5, 0x9c, 0x3c, 0x2f, 0x5c, 0x9e, 0x84, 0x8c, 0x5b, 0x8c, 0x96, 0xed, 0x0b, 0x56, 0xe8, 0x3f, 0x82, 0xb4, 0xb0, 0x48, 0x56, 0x2a, 0x21, 0x2b, 0x11, 0xa4, 0x3c, 0xfb, 0x5b, 0x22, 0xa9, 0x22, 0xc6, 0xc6, 0x7b, 0xd8, 0x68, 0x5b, 0xe6, 0xb8, 0x39, 0xb5, 0xac, 0xe0, 0x04, 0xfb, 0x90, 0xeb, 0xbb, 0x74, 0xd4, 0xe1, 0x0c, 0xf6, 0xe9, 0x99, 0xe5, 0xf3, 0x5b, 0xf2, 0x82, 0x76, 0x20, 0xc3, 0xa8, 0x70, 0xa8, 0x3e, 0x6f, 0x19, 0xe5, 0xe6, 0x6d, 0x48, 0x3b, 0xf6, 0xc8, 0x66, 0xa2, 0x94, 0x29, 0xec, 0x4f, 0x8c, 0x5b, 0xd0, 0x66, 0xd0, 0xf2, 0x60, 0xf2, 0x62, 0x28, 0xe1, 0xc5, 0x40, 0xa7, 0x90, 0xb2, 0xc7, 0x7d, 0x2a, 0x1b, 0xba, 0x79, 0x11, 0xdc, 0x5f, 0xbe, 0x4c, 0xd0, 0x49, 0xb8, 0x8d, 0x7f, 0x2b, 0x50, 0xac, 0xd0, 0xd1, 0xc4, 0xb4, 0x7e, 0xd8, 0x8d, 0x8c, 0x1e, 0x2a, 0xb9, 0xea, 0x50, 0xa9, 0xe8, 0xa1, 0x4a, 0x90, 0x65, 0x1f, 0x5c, 0x62, 0xf6, 0xbc, 0x52, 0xba, 0xac, 0x9c, 0xaf, 0xe3, 0x60, 0x8a, 0xba, 0x70, 0xd0, 0xa5, 0x8c, 0xd1, 0xd1, 0x88, 0x7a, 0xac, 0xe3, 0x90, 0x29, 0x71, 0x3a, 0x96, 0x9f, 0x9b, 0x4d, 0xc7, 0xa5, 0x8c, 0xc8, 0xc8, 0x08, 0x33, 0xba, 0x0e, 0x63, 0xef, 0x78, 0x68, 0x25, 0x8c, 0xc4, 0xfb, 0xdd, 0x55, 0x2e, 0x63, 0x13, 0x36, 0xc2, 0xe3, 0xfa, 0xb5, 0x33, 0x6e, 0x60, 0xb7, 0x31, 0xfe, 0x86, 0x58, 0xec, 0xc6, 0xb4, 0x9d, 0x7b, 0x6a, 0x8f, 0xc3, 0x4a, 0x20, 0x48, 0x8d, 0xcd, 0x11, 0x91, 0xad, 0x16, 0x63, 0x9e, 0xbe, 0x0f, 0xe5, 0xc9, 0x2a, 0x04, 0x53, 0x63, 0x1f, 0xf6, 0x16, 0x70, 0xe4, 0x16, 0x3f, 0x86, 0x3d, 0x4c, 0x2c, 0x3a, 0x25, 0xee, 0x6b, 0xf6, 0x30, 0x74, 0x28, 0x2d, 0x86, 0x4b, 0xa8, 0x3d, 0xd8, 0xb9, 0xb3, 0xbd, 0xd9, 0x1e, 0x9e, 0x04, 0x32, 0xbe, 0x53, 0x60, 0x37, 0xee, 0x91, 0xec, 0xf8, 0x4d, 0x9c, 0xf6, 0xa7, 0x61, 0x11, 0x97, 0xaf, 0x88, 0x53, 0xff, 0x67, 0x01, 0xf5, 0xff, 0xbf, 0x8a, 0x9c, 0xc2, 0x66, 0x9d, 0xb0, 0x26, 0x61, 0xae, 0x6d, 0x05, 0x79, 0x72, 0xaa, 0x9a, 0x8e, 0x23, 0x10, 0x72, 0x98, 0x0f, 0x8d, 0xbf, 0x2a, 0x80, 0xa2, 0x71, 0x32, 0xeb, 0x23, 0x80, 0x89, 0x4b, 0x47, 0x84, 0x7d, 0x20, 0xcf, 0x9e, 0xdc, 0x31, 0x62, 0x41, 0x87, 0x00, 0x2e, 0xb5, 0x86, 0x5e, 0xaf, 0xdb, 0x19, 0x4e, 0xe5, 0xd6, 0x79, 0x69, 0xb9, 0x9d, 0xa2, 0x13, 0x58, 0x0b, 0xdc, 0xfc, 0x0b, 0x24, 0xd8, 0x99, 0xc7, 0x05, 0x69, 0xe3, 0x5f, 0x34, 0xa4, 0x43, 0xee, 0x1b, 0x32, 0x32, 0x1d, 0x87, 0x5a, 0x82, 0xa3, 0x79, 0x1c, 0xce, 0x39, 0xb1, 0x3d, 0x46, 0x5d, 0xc2, 0x3f, 0x37, 0x69, 0x71, 0xfd, 0xb2, 0x62, 0xde, 0xe8, 0x19, 0xbf, 0x82, 0x43, 0xff, 0x6b, 0x51, 0xa1, 0x63, 0xcf, 0xf6, 0x18, 0x19, 0x5b, 0x2f, 0x95, 0x0f, 0xc4, 0x1a, 0xbe, 0xea, 0xab, 0x5e, 0x86, 0xa3, 0x55, 0xab, 0x65, 0x8b, 0xff, 0xa4, 0xc0, 0x5e, 0x93, 0xf6, 0xec, 0xfe, 0xcb, 0x83, 0x3d, 0x9c, 0x56, 0xe8, 0xb8, 0x6f, 0x87, 0xc2, 0x75, 0x06, 0x99, 0x11, 0xed, 0x3d, 0x3b, 0x44, 0x5e, 0xd0, 0x8d, 0xb0, 0x93, 0xcd, 0x56, 0xf5, 0xf1, 0xae, 0x86, 0xa5, 0x1b, 0x1d, 0x43, 0xc1, 0x12, 0x2b, 0x3b, 0xa2, 0x61, 0x7e, 0x79, 0xc0, 0x37, 0xbd, 0xe3, 0x6d, 0x3b, 0x81, 0x35, 0x19, 0xe0, 0x2b, 0xa6, 0xac, 0x8f, 0x6f, 0x7b, 0x12, 0xba, 0xa9, 0x43, 0x69, 0x31, 0x0f, 0x99, 0xe4, 0x57, 0x90, 0xbb, 0x77, 0xe9, 0x84, 0xb8, 0x6c, 0x39, 0x2b, 0x42, 0x25, 0xf6, 0x77, 0x96, 0x4a, 0xfc, 0x0b, 0xd0, 0x85, 0x5c, 0xf3, 0xf3, 0xcb, 0xe5, 0x36, 0xf1, 0x5e, 0x55, 0xb7, 0x1b, 0x38, 0x58, 0xba, 0x54, 0xb2, 0xe5, 0x0c, 0xd2, 0x13, 0x97, 0x4e, 0x02, 0x86, 0x6f, 0x86, 0x75, 0x09, 0xb2, 0xc4, 0xbe, 0xdf, 0xd8, 0x81, 0xad, 0x3a, 0x61, 0x6d, 0xd1, 0xcb, 0x99, 0x12, 0x1b, 0x03, 0xd8, 0x9e, 0x37, 0x4b, 0xdc, 0x28, 0x0f, 0x94, 0x39, 0x1e, 0xa0, 0xaf, 0xa0, 0x60, 0x4e, 0xec, 0xce, 0x94, 0xb8, 0x1e, 0xff, 0x3e, 0xa9, 0xa2, 0x21, 0x5b, 0xe1, 0x97, 0xf6, 0xea, 0xbe, 0xf1, 0xe4, 0xbb, 0x30, 0x98, 0x13, 0x5b, 0x8e, 0xf9, 0x05, 0xae, 0x13, 0x56, 0x71, 0x9e, 0x3d, 0x46, 0xdc, 0x68, 0x06, 0x5f, 0xc3, 0x6e, 0xdc, 0x21, 0x73, 0x38, 0x04, 0xb0, 0x7c, 0xf3, 0x2c, 0x8b, 0xbc, 0xb4, 0x34, 0x7a, 0xc6, 0xa1, 0xa8, 0xcc, 0x95, 0xe3, 0xf8, 0xc5, 0xf1, 0x1a, 0x63, 0x71, 0x8c, 0x00, 0xf7, 0xe7, 0xf0, 0xd9, 0x72, 0xb7, 0x44, 0x2f, 0x41, 0xd6, 0x2f, 0xb2, 0x5f, 0xbb, 0x14, 0x0e, 0xa6, 0xc6, 0x19, 0xec, 0x60, 0xe2, 0x11, 0xf6, 0x40, 0x83, 0x83, 0xc8, 0x46, 0x15, 0x41, 0x65, 0x9e, 0x4c, 0x44, 0x65, 0x9e, 0x51, 0x82, 0xdd, 0x78, 0xa0, 0x0f, 0xfe, 0xf6, 0x0d, 0xa8, 0xd5, 0x6b, 0x54, 0x80, 0x6c, 0xe3, 0xdd, 0xd3, 0xd5, 0x5d, 0xa3, 0xaa, 0x25, 0x50, 0x06, 0xd4, 0xdb, 0x27, 0x4d, 0x41, 0x39, 0x48, 0xe1, 0xab, 0x9b, 0x07, 0x4d, 0x7d, 0xfb, 0x9d, 0x02, 0x19, 0x9f, 0xbe, 0x08, 0x20, 0xf3, 0xf8, 0xee, 0xb1, 0x5d, 0xe3, 0x81, 0x39, 0x48, 0xdd, 0x3e, 0x55, 0xaf, 0x35, 0x85, 0x5b, 0x79, 0x68, 0xf5, 0x5a, 0x53, 0xd1, 0x1a, 0xe4, 0x70, 0xed, 0xaa, 0x7a, 0xdf, 0x6a, 0xdd, 0x69, 0x49, 0xee, 0x69, 0xd7, 0xf0, 0x53, 0x0d, 0x6b, 0x29, 0xbe, 0x4b, 0xfb, 0xa1, 0x85, 0xaf, 0xea, 0x35, 0x2d, 0xcd, 0x77, 0xb9, 0xaf, 0x6a, 0x19, 0x1e, 0xd0, 0xac, 0x3d, 0xe0, 0x46, 0x45, 0xcb, 0xa2, 0x0d, 0x28, 0x54, 0x5a, 0xf7, 0xb8, 0x55, 0xa9, 0xb5, 0xdb, 0x2d, 0xac, 0xe5, 0x38, 0x56, 0xbb, 0x56, 0x79, 0xc4, 0x8d, 0x87, 0xf7, 0x5a, 0x9e, 0x87, 0x36, 0x9a, 0xf7, 0x2d, 0xfc, 0xa0, 0xc1, 0xdb, 0x3b, 0xd8, 0x5f, 0xa9, 0x2f, 0x3c, 0xb1, 0xf6, 0xd0, 0x9e, 0x68, 0x09, 0x94, 0x87, 0xf4, 0x0d, 0x75, 0x2d, 0xa2, 0x29, 0x48, 0x87, 0xdd, 0x46, 0xff, 0xb7, 0xe6, 0x94, 0xcc, 0x02, 0x6f, 0x6c, 0x87, 0x11, 0x57, 0x53, 0x2f, 0xff, 0x03, 0x90, 0xae, 0x72, 0x3e, 0xa2, 0x4b, 0x48, 0xd6, 0x09, 0x43, 0x5b, 0x21, 0x3d, 0x67, 0x4f, 0x61, 0x7d, 0x7b, 0xde, 0x28, 0x2f, 0x5a, 0x02, 0xfd, 0x1a, 0xb2, 0xf2, 0xc9, 0x89, 0xf6, 0x66, 0xef, 0x95, 0xb9, 0x07, 0xad, 0x5e, 0x5a, 0x74, 0x84, 0xeb, 0xeb, 0x00, 0xb3, 0x67, 0x24, 0xd2, 0x63, 0x4f, 0x9e, 0x08, 0x05, 0xf5, 0x83, 0xa5, 0xbe, 0x45, 0x20, 0xfe, 0x4c, 0x5a, 0x00, 0x8a, 0xbc, 0xd6, 0x16, 0x80, 0xa2, 0xef, 0x2a, 0x23, 0x81, 0x2a, 0x90, 0x0b, 0x9e, 0x30, 0x68, 0x96, 0x79, 0xec, 0xc1, 0xa4, 0xef, 0x2f, 0xf1, 0x04, 0x10, 0x5f, 0x2a, 0xbc, 0x2c, 0xb2, 0xd4, 0x91, 0xb2, 0xcc, 0xbf, 0x65, 0x22, 0x65, 0x89, 0xab, 0x7e, 0x02, 0x3d, 0xc1, 0x46, 0x4c, 0xaf, 0xd1, 0x71, 0x18, 0xbe, 0xfc, 0x45, 0xa0, 0x97, 0x57, 0x07, 0x84, 0xb8, 0xef, 0x41, 0x8b, 0xab, 0x37, 0x2a, 0x47, 0xea, 0xb1, 0xf4, 0x1d, 0xa0, 0x9f, 0x7c, 0x4f, 0x44, 0x08, 0xdd, 0x86, 0xe2, 0xbc, 0x60, 0xa3, 0xa3, 0x95, 0x4a, 0xee, 0xc3, 0x1e, 0x7f, 0x42, 0xe9, 0xfd, 0xae, 0xce, 0xd4, 0x37, 0xd2, 0xd5, 0x05, 0xe9, 0x8e, 0x74, 0x75, 0x51, 0xae, 0x8d, 0x04, 0x1a, 0xc2, 0xae, 0x14, 0xb2, 0x98, 0xbc, 0xa1, 0x2f, 0x62, 0x74, 0x58, 0x21, 0x9c, 0xfa, 0xd9, 0x27, 0xe3, 0xa2, 0x55, 0x8e, 0x6b, 0x53, 0xa4, 0xca, 0x2b, 0xe4, 0x33, 0x52, 0xe5, 0x95, 0xc2, 0x96, 0x40, 0x5d, 0xa1, 0x10, 0x71, 0xa5, 0x41, 0x6f, 0xe6, 0xaf, 0xe7, 0x52, 0x09, 0xd3, 0x3f, 0xff, 0xfe, 0xa0, 0x70, 0x8f, 0x26, 0xac, 0x45, 0xe5, 0x06, 0x7d, 0x16, 0x5d, 0x17, 0x17, 0x27, 0xfd, 0x70, 0x85, 0x37, 0x4a, 0x8c, 0x79, 0xed, 0x88, 0x10, 0x63, 0xa9, 0xda, 0x44, 0x88, 0xb1, 0x5c, 0x74, 0x8c, 0x04, 0x22, 0x42, 0x12, 0x17, 0x84, 0x03, 0xcd, 0x9d, 0x71, 0x95, 0xec, 0xe8, 0xa7, 0x9f, 0x88, 0x8a, 0xe6, 0x3e, 0x2f, 0x1e, 0x91, 0xdc, 0x97, 0xca, 0x4f, 0x24, 0xf7, 0xe5, 0xaa, 0x63, 0x24, 0xae, 0xbf, 0xf8, 0xc7, 0x5f, 0x72, 0xca, 0xdf, 0x3e, 0x1e, 0x29, 0x7f, 0xff, 0x78, 0xa4, 0xfc, 0xf3, 0xe3, 0x91, 0xf2, 0xe7, 0x7f, 0x1d, 0x25, 0x40, 0xa3, 0xee, 0xe0, 0x82, 0xd9, 0xc3, 0xe9, 0xc5, 0x70, 0x2a, 0xfe, 0x8c, 0xe8, 0x66, 0xc4, 0xcf, 0x4f, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0xff, 0x99, 0xbe, 0xc4, 0x07, 0x11, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/diagnosticspb/000077500000000000000000000000001421456440000177175ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/diagnosticspb/diagnosticspb.pb.go000066400000000000000000001467051421456440000235140ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: diagnosticspb.proto package diagnosticspb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type LogLevel int32 const ( LogLevel_UNKNOWN LogLevel = 0 LogLevel_Debug LogLevel = 1 LogLevel_Info LogLevel = 2 LogLevel_Warn LogLevel = 3 LogLevel_Trace LogLevel = 4 LogLevel_Critical LogLevel = 5 LogLevel_Error LogLevel = 6 ) var LogLevel_name = map[int32]string{ 0: "UNKNOWN", 1: "Debug", 2: "Info", 3: "Warn", 4: "Trace", 5: "Critical", 6: "Error", } var LogLevel_value = map[string]int32{ "UNKNOWN": 0, "Debug": 1, "Info": 2, "Warn": 3, "Trace": 4, "Critical": 5, "Error": 6, } func (x LogLevel) String() string { return proto.EnumName(LogLevel_name, int32(x)) } func (LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{0} } type ServerInfoType int32 const ( ServerInfoType_All ServerInfoType = 0 ServerInfoType_HardwareInfo ServerInfoType = 1 ServerInfoType_SystemInfo ServerInfoType = 2 ServerInfoType_LoadInfo ServerInfoType = 3 ) var ServerInfoType_name = map[int32]string{ 0: "All", 1: "HardwareInfo", 2: "SystemInfo", 3: "LoadInfo", } var ServerInfoType_value = map[string]int32{ "All": 0, "HardwareInfo": 1, "SystemInfo": 2, "LoadInfo": 3, } func (x ServerInfoType) String() string { return proto.EnumName(ServerInfoType_name, int32(x)) } func (ServerInfoType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{1} } type SearchLogRequest_Target int32 const ( SearchLogRequest_Normal SearchLogRequest_Target = 0 SearchLogRequest_Slow SearchLogRequest_Target = 1 ) var SearchLogRequest_Target_name = map[int32]string{ 0: "Normal", 1: "Slow", } var SearchLogRequest_Target_value = map[string]int32{ "Normal": 0, "Slow": 1, } func (x SearchLogRequest_Target) String() string { return proto.EnumName(SearchLogRequest_Target_name, int32(x)) } func (SearchLogRequest_Target) EnumDescriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{0, 0} } type SearchLogRequest struct { StartTime int64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` EndTime int64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` Levels []LogLevel `protobuf:"varint,3,rep,packed,name=levels,enum=diagnosticspb.LogLevel" json:"levels,omitempty"` // We use a string array to represent multiple CNF pattern sceniaor like: // SELECT * FROM t WHERE c LIKE '%s%' and c REGEXP '.*a.*' because // Golang and Rust don't support perl-like (?=re1)(?=re2) Patterns []string `protobuf:"bytes,4,rep,name=patterns" json:"patterns,omitempty"` Target SearchLogRequest_Target `protobuf:"varint,5,opt,name=target,proto3,enum=diagnosticspb.SearchLogRequest_Target" json:"target,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SearchLogRequest) Reset() { *m = SearchLogRequest{} } func (m *SearchLogRequest) String() string { return proto.CompactTextString(m) } func (*SearchLogRequest) ProtoMessage() {} func (*SearchLogRequest) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{0} } func (m *SearchLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SearchLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SearchLogRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SearchLogRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SearchLogRequest.Merge(dst, src) } func (m *SearchLogRequest) XXX_Size() int { return m.Size() } func (m *SearchLogRequest) XXX_DiscardUnknown() { xxx_messageInfo_SearchLogRequest.DiscardUnknown(m) } var xxx_messageInfo_SearchLogRequest proto.InternalMessageInfo func (m *SearchLogRequest) GetStartTime() int64 { if m != nil { return m.StartTime } return 0 } func (m *SearchLogRequest) GetEndTime() int64 { if m != nil { return m.EndTime } return 0 } func (m *SearchLogRequest) GetLevels() []LogLevel { if m != nil { return m.Levels } return nil } func (m *SearchLogRequest) GetPatterns() []string { if m != nil { return m.Patterns } return nil } func (m *SearchLogRequest) GetTarget() SearchLogRequest_Target { if m != nil { return m.Target } return SearchLogRequest_Normal } type SearchLogResponse struct { Messages []*LogMessage `protobuf:"bytes,1,rep,name=messages" json:"messages,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SearchLogResponse) Reset() { *m = SearchLogResponse{} } func (m *SearchLogResponse) String() string { return proto.CompactTextString(m) } func (*SearchLogResponse) ProtoMessage() {} func (*SearchLogResponse) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{1} } func (m *SearchLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SearchLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SearchLogResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SearchLogResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SearchLogResponse.Merge(dst, src) } func (m *SearchLogResponse) XXX_Size() int { return m.Size() } func (m *SearchLogResponse) XXX_DiscardUnknown() { xxx_messageInfo_SearchLogResponse.DiscardUnknown(m) } var xxx_messageInfo_SearchLogResponse proto.InternalMessageInfo func (m *SearchLogResponse) GetMessages() []*LogMessage { if m != nil { return m.Messages } return nil } type LogMessage struct { Time int64 `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"` Level LogLevel `protobuf:"varint,2,opt,name=level,proto3,enum=diagnosticspb.LogLevel" json:"level,omitempty"` Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LogMessage) Reset() { *m = LogMessage{} } func (m *LogMessage) String() string { return proto.CompactTextString(m) } func (*LogMessage) ProtoMessage() {} func (*LogMessage) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{2} } func (m *LogMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LogMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LogMessage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LogMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_LogMessage.Merge(dst, src) } func (m *LogMessage) XXX_Size() int { return m.Size() } func (m *LogMessage) XXX_DiscardUnknown() { xxx_messageInfo_LogMessage.DiscardUnknown(m) } var xxx_messageInfo_LogMessage proto.InternalMessageInfo func (m *LogMessage) GetTime() int64 { if m != nil { return m.Time } return 0 } func (m *LogMessage) GetLevel() LogLevel { if m != nil { return m.Level } return LogLevel_UNKNOWN } func (m *LogMessage) GetMessage() string { if m != nil { return m.Message } return "" } type ServerInfoRequest struct { Tp ServerInfoType `protobuf:"varint,1,opt,name=tp,proto3,enum=diagnosticspb.ServerInfoType" json:"tp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerInfoRequest) Reset() { *m = ServerInfoRequest{} } func (m *ServerInfoRequest) String() string { return proto.CompactTextString(m) } func (*ServerInfoRequest) ProtoMessage() {} func (*ServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{3} } func (m *ServerInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ServerInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerInfoRequest.Merge(dst, src) } func (m *ServerInfoRequest) XXX_Size() int { return m.Size() } func (m *ServerInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_ServerInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_ServerInfoRequest proto.InternalMessageInfo func (m *ServerInfoRequest) GetTp() ServerInfoType { if m != nil { return m.Tp } return ServerInfoType_All } type ServerInfoPair struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerInfoPair) Reset() { *m = ServerInfoPair{} } func (m *ServerInfoPair) String() string { return proto.CompactTextString(m) } func (*ServerInfoPair) ProtoMessage() {} func (*ServerInfoPair) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{4} } func (m *ServerInfoPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerInfoPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerInfoPair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ServerInfoPair) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerInfoPair.Merge(dst, src) } func (m *ServerInfoPair) XXX_Size() int { return m.Size() } func (m *ServerInfoPair) XXX_DiscardUnknown() { xxx_messageInfo_ServerInfoPair.DiscardUnknown(m) } var xxx_messageInfo_ServerInfoPair proto.InternalMessageInfo func (m *ServerInfoPair) GetKey() string { if m != nil { return m.Key } return "" } func (m *ServerInfoPair) GetValue() string { if m != nil { return m.Value } return "" } type ServerInfoItem struct { // cpu, memory, disk, network ... Tp string `protobuf:"bytes,1,opt,name=tp,proto3" json:"tp,omitempty"` // eg. network: lo1/eth0, cpu: core1/core2, disk: sda1/sda2 Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` // all key-value pairs for specified item, e.g: // ServerInfoItem { // tp = "network" // name = "eth0" // paris = [ // ServerInfoPair { key = "readbytes", value = "4k"}, // ServerInfoPair { key = "writebytes", value = "1k"}, // ] // } Pairs []*ServerInfoPair `protobuf:"bytes,3,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerInfoItem) Reset() { *m = ServerInfoItem{} } func (m *ServerInfoItem) String() string { return proto.CompactTextString(m) } func (*ServerInfoItem) ProtoMessage() {} func (*ServerInfoItem) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{5} } func (m *ServerInfoItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerInfoItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerInfoItem.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ServerInfoItem) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerInfoItem.Merge(dst, src) } func (m *ServerInfoItem) XXX_Size() int { return m.Size() } func (m *ServerInfoItem) XXX_DiscardUnknown() { xxx_messageInfo_ServerInfoItem.DiscardUnknown(m) } var xxx_messageInfo_ServerInfoItem proto.InternalMessageInfo func (m *ServerInfoItem) GetTp() string { if m != nil { return m.Tp } return "" } func (m *ServerInfoItem) GetName() string { if m != nil { return m.Name } return "" } func (m *ServerInfoItem) GetPairs() []*ServerInfoPair { if m != nil { return m.Pairs } return nil } type ServerInfoResponse struct { Items []*ServerInfoItem `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerInfoResponse) Reset() { *m = ServerInfoResponse{} } func (m *ServerInfoResponse) String() string { return proto.CompactTextString(m) } func (*ServerInfoResponse) ProtoMessage() {} func (*ServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_diagnosticspb_38cac8120806ca82, []int{6} } func (m *ServerInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ServerInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerInfoResponse.Merge(dst, src) } func (m *ServerInfoResponse) XXX_Size() int { return m.Size() } func (m *ServerInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_ServerInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_ServerInfoResponse proto.InternalMessageInfo func (m *ServerInfoResponse) GetItems() []*ServerInfoItem { if m != nil { return m.Items } return nil } func init() { proto.RegisterType((*SearchLogRequest)(nil), "diagnosticspb.SearchLogRequest") proto.RegisterType((*SearchLogResponse)(nil), "diagnosticspb.SearchLogResponse") proto.RegisterType((*LogMessage)(nil), "diagnosticspb.LogMessage") proto.RegisterType((*ServerInfoRequest)(nil), "diagnosticspb.ServerInfoRequest") proto.RegisterType((*ServerInfoPair)(nil), "diagnosticspb.ServerInfoPair") proto.RegisterType((*ServerInfoItem)(nil), "diagnosticspb.ServerInfoItem") proto.RegisterType((*ServerInfoResponse)(nil), "diagnosticspb.ServerInfoResponse") proto.RegisterEnum("diagnosticspb.LogLevel", LogLevel_name, LogLevel_value) proto.RegisterEnum("diagnosticspb.ServerInfoType", ServerInfoType_name, ServerInfoType_value) proto.RegisterEnum("diagnosticspb.SearchLogRequest_Target", SearchLogRequest_Target_name, SearchLogRequest_Target_value) } // 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 // Client API for Diagnostics service type DiagnosticsClient interface { // Searchs log in the target node SearchLog(ctx context.Context, in *SearchLogRequest, opts ...grpc.CallOption) (Diagnostics_SearchLogClient, error) // Retrieves server info in the target node ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error) } type diagnosticsClient struct { cc *grpc.ClientConn } func NewDiagnosticsClient(cc *grpc.ClientConn) DiagnosticsClient { return &diagnosticsClient{cc} } func (c *diagnosticsClient) SearchLog(ctx context.Context, in *SearchLogRequest, opts ...grpc.CallOption) (Diagnostics_SearchLogClient, error) { stream, err := c.cc.NewStream(ctx, &_Diagnostics_serviceDesc.Streams[0], "/diagnosticspb.Diagnostics/search_log", opts...) if err != nil { return nil, err } x := &diagnosticsSearchLogClient{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 Diagnostics_SearchLogClient interface { Recv() (*SearchLogResponse, error) grpc.ClientStream } type diagnosticsSearchLogClient struct { grpc.ClientStream } func (x *diagnosticsSearchLogClient) Recv() (*SearchLogResponse, error) { m := new(SearchLogResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *diagnosticsClient) ServerInfo(ctx context.Context, in *ServerInfoRequest, opts ...grpc.CallOption) (*ServerInfoResponse, error) { out := new(ServerInfoResponse) err := c.cc.Invoke(ctx, "/diagnosticspb.Diagnostics/server_info", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for Diagnostics service type DiagnosticsServer interface { // Searchs log in the target node SearchLog(*SearchLogRequest, Diagnostics_SearchLogServer) error // Retrieves server info in the target node ServerInfo(context.Context, *ServerInfoRequest) (*ServerInfoResponse, error) } func RegisterDiagnosticsServer(s *grpc.Server, srv DiagnosticsServer) { s.RegisterService(&_Diagnostics_serviceDesc, srv) } func _Diagnostics_SearchLog_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SearchLogRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(DiagnosticsServer).SearchLog(m, &diagnosticsSearchLogServer{stream}) } type Diagnostics_SearchLogServer interface { Send(*SearchLogResponse) error grpc.ServerStream } type diagnosticsSearchLogServer struct { grpc.ServerStream } func (x *diagnosticsSearchLogServer) Send(m *SearchLogResponse) error { return x.ServerStream.SendMsg(m) } func _Diagnostics_ServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ServerInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DiagnosticsServer).ServerInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/diagnosticspb.Diagnostics/ServerInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DiagnosticsServer).ServerInfo(ctx, req.(*ServerInfoRequest)) } return interceptor(ctx, in, info, handler) } var _Diagnostics_serviceDesc = grpc.ServiceDesc{ ServiceName: "diagnosticspb.Diagnostics", HandlerType: (*DiagnosticsServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "server_info", Handler: _Diagnostics_ServerInfo_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "search_log", Handler: _Diagnostics_SearchLog_Handler, ServerStreams: true, }, }, Metadata: "diagnosticspb.proto", } func (m *SearchLogRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SearchLogRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTime != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.StartTime)) } if m.EndTime != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.EndTime)) } if len(m.Levels) > 0 { dAtA2 := make([]byte, len(m.Levels)*10) var j1 int for _, num := range m.Levels { for num >= 1<<7 { dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j1++ } dAtA2[j1] = uint8(num) j1++ } dAtA[i] = 0x1a i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(j1)) i += copy(dAtA[i:], dAtA2[:j1]) } if len(m.Patterns) > 0 { for _, s := range m.Patterns { dAtA[i] = 0x22 i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if m.Target != 0 { dAtA[i] = 0x28 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.Target)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SearchLogResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SearchLogResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Messages) > 0 { for _, msg := range m.Messages { dAtA[i] = 0xa i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LogMessage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LogMessage) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Time != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.Time)) } if m.Level != 0 { dAtA[i] = 0x10 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.Level)) } if len(m.Message) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ServerInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Tp != 0 { dAtA[i] = 0x8 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(m.Tp)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ServerInfoPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerInfoPair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ServerInfoItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerInfoItem) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Tp) > 0 { dAtA[i] = 0xa i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(len(m.Tp))) i += copy(dAtA[i:], m.Tp) } if len(m.Name) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x1a i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ServerInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Items) > 0 { for _, msg := range m.Items { dAtA[i] = 0xa i++ i = encodeVarintDiagnosticspb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintDiagnosticspb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *SearchLogRequest) Size() (n int) { var l int _ = l if m.StartTime != 0 { n += 1 + sovDiagnosticspb(uint64(m.StartTime)) } if m.EndTime != 0 { n += 1 + sovDiagnosticspb(uint64(m.EndTime)) } if len(m.Levels) > 0 { l = 0 for _, e := range m.Levels { l += sovDiagnosticspb(uint64(e)) } n += 1 + sovDiagnosticspb(uint64(l)) + l } if len(m.Patterns) > 0 { for _, s := range m.Patterns { l = len(s) n += 1 + l + sovDiagnosticspb(uint64(l)) } } if m.Target != 0 { n += 1 + sovDiagnosticspb(uint64(m.Target)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SearchLogResponse) Size() (n int) { var l int _ = l if len(m.Messages) > 0 { for _, e := range m.Messages { l = e.Size() n += 1 + l + sovDiagnosticspb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LogMessage) Size() (n int) { var l int _ = l if m.Time != 0 { n += 1 + sovDiagnosticspb(uint64(m.Time)) } if m.Level != 0 { n += 1 + sovDiagnosticspb(uint64(m.Level)) } l = len(m.Message) if l > 0 { n += 1 + l + sovDiagnosticspb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerInfoRequest) Size() (n int) { var l int _ = l if m.Tp != 0 { n += 1 + sovDiagnosticspb(uint64(m.Tp)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerInfoPair) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovDiagnosticspb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovDiagnosticspb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerInfoItem) Size() (n int) { var l int _ = l l = len(m.Tp) if l > 0 { n += 1 + l + sovDiagnosticspb(uint64(l)) } l = len(m.Name) if l > 0 { n += 1 + l + sovDiagnosticspb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovDiagnosticspb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerInfoResponse) Size() (n int) { var l int _ = l if len(m.Items) > 0 { for _, e := range m.Items { l = e.Size() n += 1 + l + sovDiagnosticspb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovDiagnosticspb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozDiagnosticspb(x uint64) (n int) { return sovDiagnosticspb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *SearchLogRequest) 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 ErrIntOverflowDiagnosticspb } 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: SearchLogRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SearchLogRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) } m.StartTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTime |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) } m.EndTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndTime |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType == 0 { var v LogLevel for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (LogLevel(b) & 0x7F) << shift if b < 0x80 { break } } m.Levels = append(m.Levels, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v LogLevel for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (LogLevel(b) & 0x7F) << shift if b < 0x80 { break } } m.Levels = append(m.Levels, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Levels", wireType) } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Patterns", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Patterns = append(m.Patterns, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } m.Target = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Target |= (SearchLogRequest_Target(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *SearchLogResponse) 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 ErrIntOverflowDiagnosticspb } 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: SearchLogResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SearchLogResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Messages = append(m.Messages, &LogMessage{}) if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *LogMessage) 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 ErrIntOverflowDiagnosticspb } 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: LogMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LogMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) } m.Time = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Time |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType) } m.Level = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Level |= (LogLevel(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *ServerInfoRequest) 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 ErrIntOverflowDiagnosticspb } 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: ServerInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) } m.Tp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Tp |= (ServerInfoType(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *ServerInfoPair) 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 ErrIntOverflowDiagnosticspb } 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: ServerInfoPair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerInfoPair: 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 ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *ServerInfoItem) 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 ErrIntOverflowDiagnosticspb } 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: ServerInfoItem: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerInfoItem: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Tp = 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 ErrIntOverflowDiagnosticspb } 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 ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + intStringLen 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 Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &ServerInfoPair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 *ServerInfoResponse) 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 ErrIntOverflowDiagnosticspb } 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: ServerInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowDiagnosticspb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthDiagnosticspb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Items = append(m.Items, &ServerInfoItem{}) if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDiagnosticspb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthDiagnosticspb } 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 skipDiagnosticspb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiagnosticspb } 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, ErrIntOverflowDiagnosticspb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiagnosticspb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthDiagnosticspb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowDiagnosticspb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipDiagnosticspb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthDiagnosticspb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowDiagnosticspb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("diagnosticspb.proto", fileDescriptor_diagnosticspb_38cac8120806ca82) } var fileDescriptor_diagnosticspb_38cac8120806ca82 = []byte{ // 640 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0xc1, 0x6e, 0xd3, 0x4c, 0x10, 0xce, 0xc6, 0x71, 0x62, 0x4f, 0xfa, 0xe7, 0x37, 0x4b, 0x25, 0xdc, 0x48, 0x0d, 0xc6, 0x87, 0x2a, 0xaa, 0xd4, 0x14, 0xa5, 0x42, 0xe2, 0x84, 0x44, 0x29, 0x12, 0x81, 0x12, 0x90, 0x13, 0x54, 0x89, 0x4b, 0xb5, 0x4d, 0xb6, 0x66, 0x55, 0xdb, 0x6b, 0x76, 0x37, 0xa9, 0xfa, 0x26, 0x3c, 0x02, 0x8f, 0xc0, 0x23, 0x70, 0xe4, 0xc8, 0x11, 0x95, 0xa7, 0xe0, 0x86, 0x76, 0x1d, 0xb7, 0x69, 0xab, 0x96, 0x93, 0x67, 0x67, 0xbe, 0xfd, 0xf6, 0x9b, 0x6f, 0x46, 0x86, 0xfb, 0x53, 0x46, 0xe2, 0x8c, 0x4b, 0xc5, 0x26, 0x32, 0x3f, 0xea, 0xe5, 0x82, 0x2b, 0x8e, 0xff, 0xbb, 0x92, 0x6c, 0xaf, 0xc6, 0x3c, 0xe6, 0xa6, 0xb2, 0xad, 0xa3, 0x02, 0xd4, 0xfe, 0x5f, 0xcc, 0xa4, 0x32, 0x61, 0x91, 0x08, 0xff, 0x20, 0xf0, 0x46, 0x94, 0x88, 0xc9, 0xa7, 0x7d, 0x1e, 0x47, 0xf4, 0xf3, 0x8c, 0x4a, 0x85, 0xd7, 0x01, 0xa4, 0x22, 0x42, 0x1d, 0x2a, 0x96, 0x52, 0x1f, 0x05, 0xa8, 0x6b, 0x45, 0xae, 0xc9, 0x8c, 0x59, 0x4a, 0xf1, 0x1a, 0x38, 0x34, 0x9b, 0x16, 0xc5, 0xaa, 0x29, 0x36, 0x68, 0x36, 0x35, 0xa5, 0x6d, 0xa8, 0x27, 0x74, 0x4e, 0x13, 0xe9, 0x5b, 0x81, 0xd5, 0x6d, 0xf5, 0x1f, 0xf4, 0xae, 0x4a, 0xdd, 0xe7, 0xf1, 0xbe, 0xae, 0x47, 0x0b, 0x18, 0x6e, 0x83, 0x93, 0x13, 0xa5, 0xa8, 0xc8, 0xa4, 0x5f, 0x0b, 0xac, 0xae, 0x1b, 0x5d, 0x9c, 0xf1, 0x33, 0xa8, 0x2b, 0x22, 0x62, 0xaa, 0x7c, 0x3b, 0x40, 0xdd, 0x56, 0x7f, 0xe3, 0x1a, 0xd9, 0x75, 0xdd, 0xbd, 0xb1, 0x41, 0x47, 0x8b, 0x5b, 0x61, 0x07, 0xea, 0x45, 0x06, 0x03, 0xd4, 0x87, 0x5c, 0xa4, 0x24, 0xf1, 0x2a, 0xd8, 0x81, 0xda, 0x28, 0xe1, 0xa7, 0x1e, 0x0a, 0x5f, 0xc3, 0xbd, 0x25, 0x0a, 0x99, 0xf3, 0x4c, 0x52, 0xfc, 0x04, 0x9c, 0x94, 0x4a, 0x49, 0x62, 0x2a, 0x7d, 0x14, 0x58, 0xdd, 0x66, 0x7f, 0xed, 0x66, 0x0f, 0x6f, 0x0b, 0x44, 0x74, 0x01, 0x0d, 0x19, 0xc0, 0x65, 0x1e, 0x63, 0xa8, 0x2d, 0x59, 0x67, 0x62, 0xbc, 0x05, 0xb6, 0xe9, 0xd9, 0x58, 0x76, 0x87, 0x33, 0x05, 0x0a, 0xfb, 0xd0, 0x58, 0x90, 0xfb, 0x56, 0x80, 0xba, 0x6e, 0x54, 0x1e, 0xc3, 0x5d, 0x2d, 0x5b, 0xcc, 0xa9, 0x18, 0x64, 0xc7, 0xbc, 0x1c, 0xd9, 0x16, 0x54, 0x55, 0x6e, 0xde, 0x6b, 0xf5, 0xd7, 0x6f, 0xf8, 0x54, 0xa2, 0xc7, 0x67, 0x39, 0x8d, 0xaa, 0x2a, 0x0f, 0x9f, 0x42, 0xeb, 0x32, 0xfb, 0x9e, 0x30, 0x81, 0x3d, 0xb0, 0x4e, 0xe8, 0x99, 0x61, 0x70, 0x23, 0x1d, 0xe2, 0x55, 0xb0, 0xe7, 0x24, 0x99, 0x15, 0x33, 0x76, 0xa3, 0xe2, 0x10, 0xb2, 0xe5, 0x9b, 0x03, 0x45, 0x53, 0xdc, 0xba, 0x78, 0xda, 0xd5, 0xdc, 0xba, 0xf9, 0x8c, 0xa4, 0xe5, 0x35, 0x13, 0xe3, 0x1d, 0xb0, 0x73, 0xc2, 0x44, 0xb1, 0x16, 0xcd, 0x3b, 0x14, 0x6a, 0x2d, 0x51, 0x81, 0x0d, 0x07, 0x80, 0x97, 0x1b, 0x5d, 0x0c, 0x68, 0x07, 0x6c, 0xa6, 0x68, 0x5a, 0x4e, 0xe7, 0x76, 0x2a, 0x2d, 0x2e, 0x2a, 0xb0, 0x9b, 0x1f, 0xc1, 0x29, 0x0d, 0xc6, 0x4d, 0x68, 0x7c, 0x18, 0xbe, 0x19, 0xbe, 0x3b, 0x18, 0x7a, 0x15, 0xec, 0x82, 0xbd, 0x47, 0x8f, 0x66, 0xb1, 0x87, 0xf4, 0x62, 0xe8, 0x6b, 0x5e, 0x55, 0x47, 0x07, 0x44, 0x64, 0x9e, 0xa5, 0xcb, 0x63, 0x41, 0x26, 0xd4, 0xab, 0xe1, 0x15, 0x70, 0x5e, 0x08, 0xa6, 0xd8, 0x84, 0x24, 0x9e, 0xad, 0x0b, 0x2f, 0x85, 0xe0, 0xc2, 0xab, 0x6f, 0x0e, 0x96, 0x1d, 0xd1, 0x0e, 0xe3, 0x06, 0x58, 0xcf, 0x13, 0xbd, 0x6b, 0x1e, 0xac, 0xbc, 0x22, 0x62, 0x7a, 0x4a, 0x04, 0x35, 0xd4, 0x08, 0xb7, 0x00, 0x46, 0x67, 0x52, 0xd1, 0x74, 0xf1, 0xd4, 0x8a, 0x16, 0x46, 0xa6, 0xe6, 0x64, 0xf5, 0xbf, 0x21, 0x68, 0xee, 0x5d, 0xb6, 0x83, 0x47, 0x00, 0xd2, 0x6c, 0xe8, 0x61, 0xc2, 0x63, 0xfc, 0xf0, 0x1f, 0xfb, 0xdf, 0x0e, 0x6e, 0x07, 0x14, 0xe6, 0x85, 0x95, 0xc7, 0x08, 0x8f, 0xa1, 0x29, 0x8d, 0xde, 0x43, 0x96, 0x1d, 0x73, 0x1c, 0xdc, 0x6a, 0x60, 0x49, 0xfb, 0xe8, 0x0e, 0x44, 0xc9, 0xbb, 0xbb, 0xf1, 0xf3, 0xab, 0x83, 0xbe, 0x9f, 0x77, 0xd0, 0x8f, 0xf3, 0x0e, 0xfa, 0x75, 0xde, 0x41, 0x5f, 0x7e, 0x77, 0x2a, 0xe0, 0x71, 0x11, 0xf7, 0x14, 0x3b, 0x99, 0xf7, 0x4e, 0xe6, 0xe6, 0x87, 0x73, 0x54, 0x37, 0x9f, 0x9d, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xba, 0x18, 0xc8, 0xc4, 0x04, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/disk_usage/000077500000000000000000000000001421456440000172045ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/disk_usage/disk_usage.pb.go000066400000000000000000000045121421456440000222530ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: disk_usage.proto package disk_usage import ( "fmt" "math" proto "github.com/golang/protobuf/proto" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type DiskUsage int32 const ( DiskUsage_Normal DiskUsage = 0 DiskUsage_AlmostFull DiskUsage = 1 DiskUsage_AlreadyFull DiskUsage = 2 ) var DiskUsage_name = map[int32]string{ 0: "Normal", 1: "AlmostFull", 2: "AlreadyFull", } var DiskUsage_value = map[string]int32{ "Normal": 0, "AlmostFull": 1, "AlreadyFull": 2, } func (x DiskUsage) String() string { return proto.EnumName(DiskUsage_name, int32(x)) } func (DiskUsage) EnumDescriptor() ([]byte, []int) { return fileDescriptor_disk_usage_e896984851c5cc06, []int{0} } func init() { proto.RegisterEnum("disk_usage.DiskUsage", DiskUsage_name, DiskUsage_value) } func init() { proto.RegisterFile("disk_usage.proto", fileDescriptor_disk_usage_e896984851c5cc06) } var fileDescriptor_disk_usage_e896984851c5cc06 = []byte{ // 151 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x48, 0xc9, 0x2c, 0xce, 0x8e, 0x2f, 0x2d, 0x4e, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0x88, 0x48, 0xf1, 0x17, 0x95, 0x16, 0x97, 0x80, 0x85, 0x21, 0x92, 0x5a, 0x16, 0x5c, 0x9c, 0x2e, 0x99, 0xc5, 0xd9, 0xa1, 0x20, 0x59, 0x21, 0x2e, 0x2e, 0x36, 0xbf, 0xfc, 0xa2, 0xdc, 0xc4, 0x1c, 0x01, 0x06, 0x21, 0x3e, 0x2e, 0x2e, 0xc7, 0x9c, 0xdc, 0xfc, 0xe2, 0x12, 0xb7, 0xd2, 0x9c, 0x1c, 0x01, 0x46, 0x21, 0x7e, 0x2e, 0x6e, 0xc7, 0x9c, 0xa2, 0xd4, 0xc4, 0x94, 0x4a, 0xb0, 0x00, 0x93, 0x93, 0xda, 0x8d, 0x15, 0x1c, 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x5c, 0x02, 0xf9, 0x45, 0xe9, 0x7a, 0x25, 0x99, 0xd9, 0x65, 0x7a, 0xd9, 0x65, 0x60, 0x1b, 0x92, 0xd8, 0xc0, 0x94, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x36, 0x6c, 0xcd, 0x99, 0x00, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/encryptionpb/000077500000000000000000000000001421456440000176025ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/encryptionpb/encryptionpb.pb.go000066400000000000000000002302671421456440000232570ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: encryptionpb.proto package encryptionpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type EncryptionMethod int32 const ( EncryptionMethod_UNKNOWN EncryptionMethod = 0 EncryptionMethod_PLAINTEXT EncryptionMethod = 1 EncryptionMethod_AES128_CTR EncryptionMethod = 2 EncryptionMethod_AES192_CTR EncryptionMethod = 3 EncryptionMethod_AES256_CTR EncryptionMethod = 4 ) var EncryptionMethod_name = map[int32]string{ 0: "UNKNOWN", 1: "PLAINTEXT", 2: "AES128_CTR", 3: "AES192_CTR", 4: "AES256_CTR", } var EncryptionMethod_value = map[string]int32{ "UNKNOWN": 0, "PLAINTEXT": 1, "AES128_CTR": 2, "AES192_CTR": 3, "AES256_CTR": 4, } func (x EncryptionMethod) String() string { return proto.EnumName(EncryptionMethod_name, int32(x)) } func (EncryptionMethod) EnumDescriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{0} } // General encryption metadata for any data type. type EncryptionMeta struct { // ID of the key used to encrypt the data. KeyId uint64 `protobuf:"varint,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"` // Initialization vector (IV) of the data. Iv []byte `protobuf:"bytes,2,opt,name=iv,proto3" json:"iv,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *EncryptionMeta) Reset() { *m = EncryptionMeta{} } func (m *EncryptionMeta) String() string { return proto.CompactTextString(m) } func (*EncryptionMeta) ProtoMessage() {} func (*EncryptionMeta) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{0} } func (m *EncryptionMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *EncryptionMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EncryptionMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *EncryptionMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_EncryptionMeta.Merge(dst, src) } func (m *EncryptionMeta) XXX_Size() int { return m.Size() } func (m *EncryptionMeta) XXX_DiscardUnknown() { xxx_messageInfo_EncryptionMeta.DiscardUnknown(m) } var xxx_messageInfo_EncryptionMeta proto.InternalMessageInfo func (m *EncryptionMeta) GetKeyId() uint64 { if m != nil { return m.KeyId } return 0 } func (m *EncryptionMeta) GetIv() []byte { if m != nil { return m.Iv } return nil } // Information about an encrypted file. type FileInfo struct { // ID of the key used to encrypt the file. KeyId uint64 `protobuf:"varint,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"` // Initialization vector (IV) of the file. Iv []byte `protobuf:"bytes,2,opt,name=iv,proto3" json:"iv,omitempty"` // Method of encryption algorithm used to encrypted the file. Method EncryptionMethod `protobuf:"varint,3,opt,name=method,proto3,enum=encryptionpb.EncryptionMethod" json:"method,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *FileInfo) Reset() { *m = FileInfo{} } func (m *FileInfo) String() string { return proto.CompactTextString(m) } func (*FileInfo) ProtoMessage() {} func (*FileInfo) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{1} } func (m *FileInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *FileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FileInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *FileInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_FileInfo.Merge(dst, src) } func (m *FileInfo) XXX_Size() int { return m.Size() } func (m *FileInfo) XXX_DiscardUnknown() { xxx_messageInfo_FileInfo.DiscardUnknown(m) } var xxx_messageInfo_FileInfo proto.InternalMessageInfo func (m *FileInfo) GetKeyId() uint64 { if m != nil { return m.KeyId } return 0 } func (m *FileInfo) GetIv() []byte { if m != nil { return m.Iv } return nil } func (m *FileInfo) GetMethod() EncryptionMethod { if m != nil { return m.Method } return EncryptionMethod_UNKNOWN } type FileDictionary struct { // A map of file name to file info. Files map[string]*FileInfo `protobuf:"bytes,1,rep,name=files" json:"files,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *FileDictionary) Reset() { *m = FileDictionary{} } func (m *FileDictionary) String() string { return proto.CompactTextString(m) } func (*FileDictionary) ProtoMessage() {} func (*FileDictionary) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{2} } func (m *FileDictionary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *FileDictionary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FileDictionary.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *FileDictionary) XXX_Merge(src proto.Message) { xxx_messageInfo_FileDictionary.Merge(dst, src) } func (m *FileDictionary) XXX_Size() int { return m.Size() } func (m *FileDictionary) XXX_DiscardUnknown() { xxx_messageInfo_FileDictionary.DiscardUnknown(m) } var xxx_messageInfo_FileDictionary proto.InternalMessageInfo func (m *FileDictionary) GetFiles() map[string]*FileInfo { if m != nil { return m.Files } return nil } // The key used to encrypt the user data. type DataKey struct { // A sequence of secret bytes used to encrypt data. Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // Method of encryption algorithm used to encrypted data. Method EncryptionMethod `protobuf:"varint,2,opt,name=method,proto3,enum=encryptionpb.EncryptionMethod" json:"method,omitempty"` // Creation time of the key. CreationTime uint64 `protobuf:"varint,3,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"` // A flag for the key have ever been exposed. WasExposed bool `protobuf:"varint,4,opt,name=was_exposed,json=wasExposed,proto3" json:"was_exposed,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DataKey) Reset() { *m = DataKey{} } func (m *DataKey) String() string { return proto.CompactTextString(m) } func (*DataKey) ProtoMessage() {} func (*DataKey) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{3} } func (m *DataKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DataKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DataKey.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DataKey) XXX_Merge(src proto.Message) { xxx_messageInfo_DataKey.Merge(dst, src) } func (m *DataKey) XXX_Size() int { return m.Size() } func (m *DataKey) XXX_DiscardUnknown() { xxx_messageInfo_DataKey.DiscardUnknown(m) } var xxx_messageInfo_DataKey proto.InternalMessageInfo func (m *DataKey) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *DataKey) GetMethod() EncryptionMethod { if m != nil { return m.Method } return EncryptionMethod_UNKNOWN } func (m *DataKey) GetCreationTime() uint64 { if m != nil { return m.CreationTime } return 0 } func (m *DataKey) GetWasExposed() bool { if m != nil { return m.WasExposed } return false } type KeyDictionary struct { // A map of key ID to dat key. Keys map[uint64]*DataKey `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` // ID of a key currently in use. CurrentKeyId uint64 `protobuf:"varint,2,opt,name=current_key_id,json=currentKeyId,proto3" json:"current_key_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyDictionary) Reset() { *m = KeyDictionary{} } func (m *KeyDictionary) String() string { return proto.CompactTextString(m) } func (*KeyDictionary) ProtoMessage() {} func (*KeyDictionary) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{4} } func (m *KeyDictionary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyDictionary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyDictionary.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyDictionary) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyDictionary.Merge(dst, src) } func (m *KeyDictionary) XXX_Size() int { return m.Size() } func (m *KeyDictionary) XXX_DiscardUnknown() { xxx_messageInfo_KeyDictionary.DiscardUnknown(m) } var xxx_messageInfo_KeyDictionary proto.InternalMessageInfo func (m *KeyDictionary) GetKeys() map[uint64]*DataKey { if m != nil { return m.Keys } return nil } func (m *KeyDictionary) GetCurrentKeyId() uint64 { if m != nil { return m.CurrentKeyId } return 0 } // Master key config. type MasterKey struct { // Types that are valid to be assigned to Backend: // *MasterKey_Plaintext // *MasterKey_File // *MasterKey_Kms Backend isMasterKey_Backend `protobuf_oneof:"backend"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MasterKey) Reset() { *m = MasterKey{} } func (m *MasterKey) String() string { return proto.CompactTextString(m) } func (*MasterKey) ProtoMessage() {} func (*MasterKey) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{5} } func (m *MasterKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MasterKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MasterKey.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MasterKey) XXX_Merge(src proto.Message) { xxx_messageInfo_MasterKey.Merge(dst, src) } func (m *MasterKey) XXX_Size() int { return m.Size() } func (m *MasterKey) XXX_DiscardUnknown() { xxx_messageInfo_MasterKey.DiscardUnknown(m) } var xxx_messageInfo_MasterKey proto.InternalMessageInfo type isMasterKey_Backend interface { isMasterKey_Backend() MarshalTo([]byte) (int, error) Size() int } type MasterKey_Plaintext struct { Plaintext *MasterKeyPlaintext `protobuf:"bytes,1,opt,name=plaintext,oneof"` } type MasterKey_File struct { File *MasterKeyFile `protobuf:"bytes,2,opt,name=file,oneof"` } type MasterKey_Kms struct { Kms *MasterKeyKms `protobuf:"bytes,3,opt,name=kms,oneof"` } func (*MasterKey_Plaintext) isMasterKey_Backend() {} func (*MasterKey_File) isMasterKey_Backend() {} func (*MasterKey_Kms) isMasterKey_Backend() {} func (m *MasterKey) GetBackend() isMasterKey_Backend { if m != nil { return m.Backend } return nil } func (m *MasterKey) GetPlaintext() *MasterKeyPlaintext { if x, ok := m.GetBackend().(*MasterKey_Plaintext); ok { return x.Plaintext } return nil } func (m *MasterKey) GetFile() *MasterKeyFile { if x, ok := m.GetBackend().(*MasterKey_File); ok { return x.File } return nil } func (m *MasterKey) GetKms() *MasterKeyKms { if x, ok := m.GetBackend().(*MasterKey_Kms); ok { return x.Kms } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*MasterKey) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _MasterKey_OneofMarshaler, _MasterKey_OneofUnmarshaler, _MasterKey_OneofSizer, []interface{}{ (*MasterKey_Plaintext)(nil), (*MasterKey_File)(nil), (*MasterKey_Kms)(nil), } } func _MasterKey_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*MasterKey) // backend switch x := m.Backend.(type) { case *MasterKey_Plaintext: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Plaintext); err != nil { return err } case *MasterKey_File: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.File); err != nil { return err } case *MasterKey_Kms: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Kms); err != nil { return err } case nil: default: return fmt.Errorf("MasterKey.Backend has unexpected type %T", x) } return nil } func _MasterKey_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*MasterKey) switch tag { case 1: // backend.plaintext if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(MasterKeyPlaintext) err := b.DecodeMessage(msg) m.Backend = &MasterKey_Plaintext{msg} return true, err case 2: // backend.file if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(MasterKeyFile) err := b.DecodeMessage(msg) m.Backend = &MasterKey_File{msg} return true, err case 3: // backend.kms if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(MasterKeyKms) err := b.DecodeMessage(msg) m.Backend = &MasterKey_Kms{msg} return true, err default: return false, nil } } func _MasterKey_OneofSizer(msg proto.Message) (n int) { m := msg.(*MasterKey) // backend switch x := m.Backend.(type) { case *MasterKey_Plaintext: s := proto.Size(x.Plaintext) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *MasterKey_File: s := proto.Size(x.File) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *MasterKey_Kms: s := proto.Size(x.Kms) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } // MasterKeyPlaintext indicates content is stored as plaintext. type MasterKeyPlaintext struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MasterKeyPlaintext) Reset() { *m = MasterKeyPlaintext{} } func (m *MasterKeyPlaintext) String() string { return proto.CompactTextString(m) } func (*MasterKeyPlaintext) ProtoMessage() {} func (*MasterKeyPlaintext) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{6} } func (m *MasterKeyPlaintext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MasterKeyPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MasterKeyPlaintext.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MasterKeyPlaintext) XXX_Merge(src proto.Message) { xxx_messageInfo_MasterKeyPlaintext.Merge(dst, src) } func (m *MasterKeyPlaintext) XXX_Size() int { return m.Size() } func (m *MasterKeyPlaintext) XXX_DiscardUnknown() { xxx_messageInfo_MasterKeyPlaintext.DiscardUnknown(m) } var xxx_messageInfo_MasterKeyPlaintext proto.InternalMessageInfo // MasterKeyFile is a master key backed by a file containing encryption key in human-readable // hex format. type MasterKeyFile struct { // Local file path. Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MasterKeyFile) Reset() { *m = MasterKeyFile{} } func (m *MasterKeyFile) String() string { return proto.CompactTextString(m) } func (*MasterKeyFile) ProtoMessage() {} func (*MasterKeyFile) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{7} } func (m *MasterKeyFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MasterKeyFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MasterKeyFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MasterKeyFile) XXX_Merge(src proto.Message) { xxx_messageInfo_MasterKeyFile.Merge(dst, src) } func (m *MasterKeyFile) XXX_Size() int { return m.Size() } func (m *MasterKeyFile) XXX_DiscardUnknown() { xxx_messageInfo_MasterKeyFile.DiscardUnknown(m) } var xxx_messageInfo_MasterKeyFile proto.InternalMessageInfo func (m *MasterKeyFile) GetPath() string { if m != nil { return m.Path } return "" } // MasterKeyKms is a master key backed by KMS service that manages the encryption key, // and provide API to encrypt and decrypt a data key, which is used to encrypt the content. type MasterKeyKms struct { // KMS vendor. Vendor string `protobuf:"bytes,1,opt,name=vendor,proto3" json:"vendor,omitempty"` // KMS key id. KeyId string `protobuf:"bytes,2,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"` // KMS region. Region string `protobuf:"bytes,3,opt,name=region,proto3" json:"region,omitempty"` // KMS endpoint. Normally not needed. Endpoint string `protobuf:"bytes,4,opt,name=endpoint,proto3" json:"endpoint,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MasterKeyKms) Reset() { *m = MasterKeyKms{} } func (m *MasterKeyKms) String() string { return proto.CompactTextString(m) } func (*MasterKeyKms) ProtoMessage() {} func (*MasterKeyKms) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{8} } func (m *MasterKeyKms) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MasterKeyKms) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MasterKeyKms.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MasterKeyKms) XXX_Merge(src proto.Message) { xxx_messageInfo_MasterKeyKms.Merge(dst, src) } func (m *MasterKeyKms) XXX_Size() int { return m.Size() } func (m *MasterKeyKms) XXX_DiscardUnknown() { xxx_messageInfo_MasterKeyKms.DiscardUnknown(m) } var xxx_messageInfo_MasterKeyKms proto.InternalMessageInfo func (m *MasterKeyKms) GetVendor() string { if m != nil { return m.Vendor } return "" } func (m *MasterKeyKms) GetKeyId() string { if m != nil { return m.KeyId } return "" } func (m *MasterKeyKms) GetRegion() string { if m != nil { return m.Region } return "" } func (m *MasterKeyKms) GetEndpoint() string { if m != nil { return m.Endpoint } return "" } type EncryptedContent struct { // Metadata of the encrypted content. // Eg. IV, method and KMS key ID // It is preferred to define new fields for extra metadata than using this metadata map. Metadata map[string][]byte `protobuf:"bytes,1,rep,name=metadata" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Encrypted content. Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` // Master key used to encrypt the content. MasterKey *MasterKey `protobuf:"bytes,3,opt,name=master_key,json=masterKey" json:"master_key,omitempty"` // Initilization vector (IV) used. Iv []byte `protobuf:"bytes,4,opt,name=iv,proto3" json:"iv,omitempty"` // Encrypted data key generated by KMS and used to actually encrypt data. // Valid only when KMS is used. CiphertextKey []byte `protobuf:"bytes,5,opt,name=ciphertext_key,json=ciphertextKey,proto3" json:"ciphertext_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *EncryptedContent) Reset() { *m = EncryptedContent{} } func (m *EncryptedContent) String() string { return proto.CompactTextString(m) } func (*EncryptedContent) ProtoMessage() {} func (*EncryptedContent) Descriptor() ([]byte, []int) { return fileDescriptor_encryptionpb_d841ba3dd655e1a0, []int{9} } func (m *EncryptedContent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *EncryptedContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EncryptedContent.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *EncryptedContent) XXX_Merge(src proto.Message) { xxx_messageInfo_EncryptedContent.Merge(dst, src) } func (m *EncryptedContent) XXX_Size() int { return m.Size() } func (m *EncryptedContent) XXX_DiscardUnknown() { xxx_messageInfo_EncryptedContent.DiscardUnknown(m) } var xxx_messageInfo_EncryptedContent proto.InternalMessageInfo func (m *EncryptedContent) GetMetadata() map[string][]byte { if m != nil { return m.Metadata } return nil } func (m *EncryptedContent) GetContent() []byte { if m != nil { return m.Content } return nil } func (m *EncryptedContent) GetMasterKey() *MasterKey { if m != nil { return m.MasterKey } return nil } func (m *EncryptedContent) GetIv() []byte { if m != nil { return m.Iv } return nil } func (m *EncryptedContent) GetCiphertextKey() []byte { if m != nil { return m.CiphertextKey } return nil } func init() { proto.RegisterType((*EncryptionMeta)(nil), "encryptionpb.EncryptionMeta") proto.RegisterType((*FileInfo)(nil), "encryptionpb.FileInfo") proto.RegisterType((*FileDictionary)(nil), "encryptionpb.FileDictionary") proto.RegisterMapType((map[string]*FileInfo)(nil), "encryptionpb.FileDictionary.FilesEntry") proto.RegisterType((*DataKey)(nil), "encryptionpb.DataKey") proto.RegisterType((*KeyDictionary)(nil), "encryptionpb.KeyDictionary") proto.RegisterMapType((map[uint64]*DataKey)(nil), "encryptionpb.KeyDictionary.KeysEntry") proto.RegisterType((*MasterKey)(nil), "encryptionpb.MasterKey") proto.RegisterType((*MasterKeyPlaintext)(nil), "encryptionpb.MasterKeyPlaintext") proto.RegisterType((*MasterKeyFile)(nil), "encryptionpb.MasterKeyFile") proto.RegisterType((*MasterKeyKms)(nil), "encryptionpb.MasterKeyKms") proto.RegisterType((*EncryptedContent)(nil), "encryptionpb.EncryptedContent") proto.RegisterMapType((map[string][]byte)(nil), "encryptionpb.EncryptedContent.MetadataEntry") proto.RegisterEnum("encryptionpb.EncryptionMethod", EncryptionMethod_name, EncryptionMethod_value) } func (m *EncryptionMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EncryptionMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.KeyId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.KeyId)) } if len(m.Iv) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Iv))) i += copy(dAtA[i:], m.Iv) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *FileInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *FileInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.KeyId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.KeyId)) } if len(m.Iv) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Iv))) i += copy(dAtA[i:], m.Iv) } if m.Method != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.Method)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *FileDictionary) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *FileDictionary) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Files) > 0 { for k, _ := range m.Files { dAtA[i] = 0xa i++ v := m.Files[k] msgSize := 0 if v != nil { msgSize = v.Size() msgSize += 1 + sovEncryptionpb(uint64(msgSize)) } mapSize := 1 + len(k) + sovEncryptionpb(uint64(len(k))) + msgSize i = encodeVarintEncryptionpb(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(k))) i += copy(dAtA[i:], k) if v != nil { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(v.Size())) n1, err := v.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DataKey) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DataKey) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Method != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.Method)) } if m.CreationTime != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.CreationTime)) } if m.WasExposed { dAtA[i] = 0x20 i++ if m.WasExposed { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KeyDictionary) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyDictionary) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Keys) > 0 { for k, _ := range m.Keys { dAtA[i] = 0xa i++ v := m.Keys[k] msgSize := 0 if v != nil { msgSize = v.Size() msgSize += 1 + sovEncryptionpb(uint64(msgSize)) } mapSize := 1 + sovEncryptionpb(uint64(k)) + msgSize i = encodeVarintEncryptionpb(dAtA, i, uint64(mapSize)) dAtA[i] = 0x8 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(k)) if v != nil { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(v.Size())) n2, err := v.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } } } if m.CurrentKeyId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.CurrentKeyId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MasterKey) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MasterKey) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Backend != nil { nn3, err := m.Backend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MasterKey_Plaintext) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Plaintext != nil { dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.Plaintext.Size())) n4, err := m.Plaintext.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } return i, nil } func (m *MasterKey_File) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.File != nil { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.File.Size())) n5, err := m.File.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } return i, nil } func (m *MasterKey_Kms) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Kms != nil { dAtA[i] = 0x1a i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.Kms.Size())) n6, err := m.Kms.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } return i, nil } func (m *MasterKeyPlaintext) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MasterKeyPlaintext) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MasterKeyFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MasterKeyFile) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Path) > 0 { dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Path))) i += copy(dAtA[i:], m.Path) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MasterKeyKms) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MasterKeyKms) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Vendor) > 0 { dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Vendor))) i += copy(dAtA[i:], m.Vendor) } if len(m.KeyId) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.KeyId))) i += copy(dAtA[i:], m.KeyId) } if len(m.Region) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Region))) i += copy(dAtA[i:], m.Region) } if len(m.Endpoint) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Endpoint))) i += copy(dAtA[i:], m.Endpoint) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *EncryptedContent) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EncryptedContent) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Metadata) > 0 { for k, _ := range m.Metadata { dAtA[i] = 0xa i++ v := m.Metadata[k] byteSize := 0 if len(v) > 0 { byteSize = 1 + len(v) + sovEncryptionpb(uint64(len(v))) } mapSize := 1 + len(k) + sovEncryptionpb(uint64(len(k))) + byteSize i = encodeVarintEncryptionpb(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(k))) i += copy(dAtA[i:], k) if len(v) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(v))) i += copy(dAtA[i:], v) } } } if len(m.Content) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Content))) i += copy(dAtA[i:], m.Content) } if m.MasterKey != nil { dAtA[i] = 0x1a i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(m.MasterKey.Size())) n7, err := m.MasterKey.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if len(m.Iv) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.Iv))) i += copy(dAtA[i:], m.Iv) } if len(m.CiphertextKey) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintEncryptionpb(dAtA, i, uint64(len(m.CiphertextKey))) i += copy(dAtA[i:], m.CiphertextKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintEncryptionpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *EncryptionMeta) Size() (n int) { var l int _ = l if m.KeyId != 0 { n += 1 + sovEncryptionpb(uint64(m.KeyId)) } l = len(m.Iv) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *FileInfo) Size() (n int) { var l int _ = l if m.KeyId != 0 { n += 1 + sovEncryptionpb(uint64(m.KeyId)) } l = len(m.Iv) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.Method != 0 { n += 1 + sovEncryptionpb(uint64(m.Method)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *FileDictionary) Size() (n int) { var l int _ = l if len(m.Files) > 0 { for k, v := range m.Files { _ = k _ = v l = 0 if v != nil { l = v.Size() l += 1 + sovEncryptionpb(uint64(l)) } mapEntrySize := 1 + len(k) + sovEncryptionpb(uint64(len(k))) + l n += mapEntrySize + 1 + sovEncryptionpb(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DataKey) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.Method != 0 { n += 1 + sovEncryptionpb(uint64(m.Method)) } if m.CreationTime != 0 { n += 1 + sovEncryptionpb(uint64(m.CreationTime)) } if m.WasExposed { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KeyDictionary) Size() (n int) { var l int _ = l if len(m.Keys) > 0 { for k, v := range m.Keys { _ = k _ = v l = 0 if v != nil { l = v.Size() l += 1 + sovEncryptionpb(uint64(l)) } mapEntrySize := 1 + sovEncryptionpb(uint64(k)) + l n += mapEntrySize + 1 + sovEncryptionpb(uint64(mapEntrySize)) } } if m.CurrentKeyId != 0 { n += 1 + sovEncryptionpb(uint64(m.CurrentKeyId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MasterKey) Size() (n int) { var l int _ = l if m.Backend != nil { n += m.Backend.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MasterKey_Plaintext) Size() (n int) { var l int _ = l if m.Plaintext != nil { l = m.Plaintext.Size() n += 1 + l + sovEncryptionpb(uint64(l)) } return n } func (m *MasterKey_File) Size() (n int) { var l int _ = l if m.File != nil { l = m.File.Size() n += 1 + l + sovEncryptionpb(uint64(l)) } return n } func (m *MasterKey_Kms) Size() (n int) { var l int _ = l if m.Kms != nil { l = m.Kms.Size() n += 1 + l + sovEncryptionpb(uint64(l)) } return n } func (m *MasterKeyPlaintext) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MasterKeyFile) Size() (n int) { var l int _ = l l = len(m.Path) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MasterKeyKms) Size() (n int) { var l int _ = l l = len(m.Vendor) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } l = len(m.KeyId) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } l = len(m.Region) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } l = len(m.Endpoint) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *EncryptedContent) Size() (n int) { var l int _ = l if len(m.Metadata) > 0 { for k, v := range m.Metadata { _ = k _ = v l = 0 if len(v) > 0 { l = 1 + len(v) + sovEncryptionpb(uint64(len(v))) } mapEntrySize := 1 + len(k) + sovEncryptionpb(uint64(len(k))) + l n += mapEntrySize + 1 + sovEncryptionpb(uint64(mapEntrySize)) } } l = len(m.Content) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.MasterKey != nil { l = m.MasterKey.Size() n += 1 + l + sovEncryptionpb(uint64(l)) } l = len(m.Iv) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } l = len(m.CiphertextKey) if l > 0 { n += 1 + l + sovEncryptionpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovEncryptionpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozEncryptionpb(x uint64) (n int) { return sovEncryptionpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *EncryptionMeta) 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 ErrIntOverflowEncryptionpb } 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: EncryptionMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EncryptionMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyId", wireType) } m.KeyId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeyId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Iv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Iv = append(m.Iv[:0], dAtA[iNdEx:postIndex]...) if m.Iv == nil { m.Iv = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *FileInfo) 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 ErrIntOverflowEncryptionpb } 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: FileInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FileInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyId", wireType) } m.KeyId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeyId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Iv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Iv = append(m.Iv[:0], dAtA[iNdEx:postIndex]...) if m.Iv == nil { m.Iv = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType) } m.Method = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Method |= (EncryptionMethod(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *FileDictionary) 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 ErrIntOverflowEncryptionpb } 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: FileDictionary: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FileDictionary: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Files == nil { m.Files = make(map[string]*FileInfo) } var mapkey string var mapvalue *FileInfo for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postStringIndexmapkey := iNdEx + intStringLenmapkey 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 ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return ErrInvalidLengthEncryptionpb } postmsgIndex := iNdEx + mapmsglen if mapmsglen < 0 { return ErrInvalidLengthEncryptionpb } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &FileInfo{} if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Files[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *DataKey) 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 ErrIntOverflowEncryptionpb } 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: DataKey: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DataKey: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType) } m.Method = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Method |= (EncryptionMethod(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreationTime", wireType) } m.CreationTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreationTime |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WasExposed", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.WasExposed = bool(v != 0) default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *KeyDictionary) 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 ErrIntOverflowEncryptionpb } 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: KeyDictionary: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyDictionary: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Keys == nil { m.Keys = make(map[uint64]*DataKey) } var mapkey uint64 var mapvalue *DataKey for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 { for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapkey |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } } else if fieldNum == 2 { var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return ErrInvalidLengthEncryptionpb } postmsgIndex := iNdEx + mapmsglen if mapmsglen < 0 { return ErrInvalidLengthEncryptionpb } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &DataKey{} if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Keys[mapkey] = mapvalue iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CurrentKeyId", wireType) } m.CurrentKeyId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CurrentKeyId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *MasterKey) 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 ErrIntOverflowEncryptionpb } 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: MasterKey: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MasterKey: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &MasterKeyPlaintext{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &MasterKey_Plaintext{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field File", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &MasterKeyFile{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &MasterKey_File{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kms", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &MasterKeyKms{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Backend = &MasterKey_Kms{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *MasterKeyPlaintext) 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 ErrIntOverflowEncryptionpb } 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: MasterKeyPlaintext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MasterKeyPlaintext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *MasterKeyFile) 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 ErrIntOverflowEncryptionpb } 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: MasterKeyFile: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MasterKeyFile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *MasterKeyKms) 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 ErrIntOverflowEncryptionpb } 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: MasterKeyKms: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MasterKeyKms: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Vendor", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Vendor = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.KeyId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 *EncryptedContent) 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 ErrIntOverflowEncryptionpb } 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: EncryptedContent: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EncryptedContent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Metadata == nil { m.Metadata = make(map[string][]byte) } var mapkey string mapvalue := []byte{} for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } 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 ErrIntOverflowEncryptionpb } 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 ErrInvalidLengthEncryptionpb } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapbyteLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapbyteLen |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } intMapbyteLen := int(mapbyteLen) if intMapbyteLen < 0 { return ErrInvalidLengthEncryptionpb } postbytesIndex := iNdEx + intMapbyteLen if postbytesIndex > l { return io.ErrUnexpectedEOF } mapvalue = make([]byte, mapbyteLen) copy(mapvalue, dAtA[iNdEx:postbytesIndex]) iNdEx = postbytesIndex } else { iNdEx = entryPreIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Metadata[mapkey] = mapvalue iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...) if m.Content == nil { m.Content = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MasterKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MasterKey == nil { m.MasterKey = &MasterKey{} } if err := m.MasterKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Iv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Iv = append(m.Iv[:0], dAtA[iNdEx:postIndex]...) if m.Iv == nil { m.Iv = []byte{} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CiphertextKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEncryptionpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEncryptionpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.CiphertextKey = append(m.CiphertextKey[:0], dAtA[iNdEx:postIndex]...) if m.CiphertextKey == nil { m.CiphertextKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEncryptionpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEncryptionpb } 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 skipEncryptionpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEncryptionpb } 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, ErrIntOverflowEncryptionpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEncryptionpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthEncryptionpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEncryptionpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipEncryptionpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthEncryptionpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowEncryptionpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("encryptionpb.proto", fileDescriptor_encryptionpb_d841ba3dd655e1a0) } var fileDescriptor_encryptionpb_d841ba3dd655e1a0 = []byte{ // 761 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5b, 0x6f, 0xd3, 0x48, 0x14, 0xce, 0x38, 0xce, 0xc5, 0x27, 0x97, 0x8d, 0x46, 0x6d, 0x37, 0xca, 0x4a, 0xd9, 0xc8, 0xdd, 0xee, 0x46, 0xbb, 0x55, 0x56, 0x35, 0xa2, 0xb4, 0x20, 0x24, 0x7a, 0x09, 0x4a, 0x15, 0x1a, 0x2a, 0x13, 0x04, 0x4f, 0x44, 0x6e, 0x3c, 0x4d, 0x2c, 0xc7, 0x17, 0xec, 0x69, 0x5a, 0xff, 0x13, 0x78, 0x84, 0x27, 0xfe, 0x03, 0x2f, 0x3c, 0xf2, 0xc8, 0x23, 0x8f, 0xa8, 0xfc, 0x11, 0xe4, 0xf1, 0xc4, 0xb1, 0xd5, 0x56, 0x82, 0x27, 0xcf, 0x39, 0xf3, 0x7d, 0xc7, 0x67, 0xbe, 0xf9, 0xe6, 0x00, 0x26, 0xf6, 0xd8, 0x0b, 0x5c, 0x6a, 0x38, 0xb6, 0x7b, 0xda, 0x71, 0x3d, 0x87, 0x3a, 0xb8, 0x9c, 0xcc, 0x35, 0x56, 0x26, 0xce, 0xc4, 0x61, 0x1b, 0xff, 0x87, 0xab, 0x08, 0xd3, 0xf8, 0xcd, 0x3b, 0xf7, 0x29, 0x5b, 0x46, 0x09, 0xf9, 0x1e, 0x54, 0xbb, 0x31, 0xed, 0x98, 0x50, 0x0d, 0xaf, 0x42, 0xde, 0x24, 0xc1, 0xc8, 0xd0, 0xeb, 0xa8, 0x85, 0xda, 0xa2, 0x9a, 0x33, 0x49, 0x70, 0xa4, 0xe3, 0x2a, 0x08, 0xc6, 0xbc, 0x2e, 0xb4, 0x50, 0xbb, 0xac, 0x0a, 0xc6, 0x5c, 0x36, 0xa0, 0xf8, 0xd8, 0x98, 0x91, 0x23, 0xfb, 0xcc, 0xf9, 0x49, 0x0a, 0xde, 0x86, 0xbc, 0x45, 0xe8, 0xd4, 0xd1, 0xeb, 0xd9, 0x16, 0x6a, 0x57, 0x95, 0x66, 0x27, 0x75, 0x8a, 0x54, 0x1f, 0x53, 0x47, 0x57, 0x39, 0x5a, 0x7e, 0x87, 0xa0, 0x1a, 0xfe, 0xeb, 0xd0, 0x18, 0x87, 0xbb, 0x9a, 0x17, 0xe0, 0x87, 0x90, 0x3b, 0x33, 0x66, 0xc4, 0xaf, 0xa3, 0x56, 0xb6, 0x5d, 0x52, 0xfe, 0x49, 0x57, 0x4a, 0x83, 0x59, 0xe8, 0x77, 0x6d, 0xea, 0x05, 0x6a, 0xc4, 0x6a, 0x9c, 0x00, 0x2c, 0x93, 0xb8, 0x06, 0x59, 0x93, 0x04, 0xac, 0x77, 0x49, 0x0d, 0x97, 0x78, 0x13, 0x72, 0x73, 0x6d, 0x76, 0x4e, 0x58, 0xf3, 0x25, 0x65, 0xed, 0x7a, 0xf9, 0xf0, 0xdc, 0x6a, 0x04, 0xba, 0x2f, 0xec, 0x20, 0xf9, 0x2d, 0x82, 0xc2, 0xa1, 0x46, 0xb5, 0x3e, 0x49, 0xd5, 0x2b, 0x47, 0xf5, 0x96, 0x27, 0x17, 0x7e, 0xe5, 0xe4, 0x78, 0x1d, 0x2a, 0x63, 0x8f, 0x68, 0xe1, 0xce, 0x88, 0x1a, 0x16, 0x61, 0xc2, 0x89, 0x6a, 0x79, 0x91, 0x1c, 0x1a, 0x16, 0xc1, 0x7f, 0x42, 0xe9, 0x42, 0xf3, 0x47, 0xe4, 0xd2, 0x75, 0x7c, 0xa2, 0xd7, 0xc5, 0x16, 0x6a, 0x17, 0x55, 0xb8, 0xd0, 0xfc, 0x6e, 0x94, 0x91, 0x3f, 0x21, 0xa8, 0xf4, 0x49, 0x90, 0x90, 0x6f, 0x17, 0x44, 0x93, 0x04, 0x0b, 0xf5, 0x36, 0xd2, 0xdd, 0xa4, 0xa0, 0x61, 0xc4, 0xb5, 0x63, 0x14, 0xfc, 0x17, 0x54, 0xc7, 0xe7, 0x9e, 0x47, 0x6c, 0x3a, 0xe2, 0x77, 0x2e, 0xf0, 0x9e, 0xa2, 0x6c, 0x3f, 0xbc, 0xfa, 0xc6, 0x00, 0xa4, 0x98, 0x98, 0xd4, 0x43, 0x8c, 0xf4, 0xf8, 0x2f, 0xad, 0xef, 0x6a, 0xba, 0x01, 0xae, 0x63, 0x52, 0xde, 0x8f, 0x08, 0xa4, 0x63, 0xcd, 0xa7, 0xc4, 0x0b, 0x05, 0x7e, 0x04, 0x92, 0x3b, 0xd3, 0x0c, 0x9b, 0x92, 0x4b, 0xca, 0xca, 0x96, 0x94, 0x56, 0xba, 0x44, 0x8c, 0x3d, 0x59, 0xe0, 0x7a, 0x19, 0x75, 0x49, 0xc2, 0x5b, 0x20, 0x86, 0x4e, 0xe0, 0xff, 0xff, 0xe3, 0x16, 0x72, 0x78, 0xd1, 0xbd, 0x8c, 0xca, 0xa0, 0xb8, 0x03, 0x59, 0xd3, 0xf2, 0xd9, 0x0d, 0x94, 0x94, 0xc6, 0x2d, 0x8c, 0xbe, 0xe5, 0xf7, 0x32, 0x6a, 0x08, 0xdc, 0x97, 0xa0, 0x70, 0xaa, 0x8d, 0x4d, 0x62, 0xeb, 0xf2, 0x0a, 0xe0, 0xeb, 0x0d, 0xc9, 0xeb, 0x50, 0x49, 0xfd, 0x09, 0x63, 0x10, 0x5d, 0x8d, 0x4e, 0xb9, 0x11, 0xd9, 0x5a, 0x7e, 0x0d, 0xe5, 0x64, 0x71, 0xbc, 0x06, 0xf9, 0x39, 0xb1, 0x75, 0xc7, 0xe3, 0x28, 0x1e, 0x25, 0x9e, 0xa0, 0xc0, 0xf2, 0xfc, 0x09, 0xae, 0x41, 0xde, 0x23, 0x13, 0xc3, 0xb1, 0x59, 0xdf, 0x92, 0xca, 0x23, 0xdc, 0x80, 0x22, 0xb1, 0x75, 0xd7, 0x31, 0x6c, 0xca, 0x0c, 0x23, 0xa9, 0x71, 0x2c, 0xbf, 0x17, 0xa0, 0xc6, 0x1d, 0x49, 0xf4, 0x03, 0xc7, 0xa6, 0xc4, 0xa6, 0xb8, 0x07, 0x45, 0x8b, 0x50, 0x4d, 0xd7, 0xa8, 0xc6, 0x5d, 0xb3, 0x79, 0xa3, 0x87, 0x63, 0x46, 0xe7, 0x98, 0xc3, 0x23, 0xf3, 0xc4, 0x6c, 0x5c, 0x87, 0xc2, 0x38, 0x82, 0xf0, 0xd1, 0xb0, 0x08, 0xf1, 0x36, 0x80, 0xc5, 0xce, 0x1a, 0x3a, 0x8b, 0x0b, 0xfd, 0xfb, 0x2d, 0x42, 0xab, 0x92, 0x15, 0xdb, 0x21, 0x9a, 0x33, 0x62, 0x3c, 0x67, 0x36, 0xa0, 0x3a, 0x36, 0xdc, 0x29, 0xf1, 0x42, 0x99, 0x59, 0xad, 0x1c, 0xdb, 0xab, 0x2c, 0xb3, 0x7d, 0x12, 0x34, 0x1e, 0x40, 0x25, 0xd5, 0xe3, 0x0d, 0x73, 0x60, 0x25, 0xe9, 0xd3, 0x72, 0xc2, 0x90, 0xff, 0xbe, 0x8a, 0x35, 0x8a, 0x5f, 0x2d, 0x2e, 0x41, 0xe1, 0xf9, 0xa0, 0x3f, 0x78, 0xfa, 0x62, 0x50, 0xcb, 0xe0, 0x0a, 0x48, 0x27, 0x4f, 0xf6, 0x8e, 0x06, 0xc3, 0xee, 0xcb, 0x61, 0x0d, 0xe1, 0x2a, 0xc0, 0x5e, 0xf7, 0xd9, 0x96, 0xb2, 0x33, 0x3a, 0x18, 0xaa, 0x35, 0x61, 0x11, 0xef, 0x2a, 0x2c, 0xce, 0xf2, 0x58, 0xb9, 0xbb, 0xcd, 0x62, 0x71, 0xff, 0xef, 0xaf, 0x1f, 0x8a, 0xe8, 0xf3, 0x55, 0x13, 0x7d, 0xb9, 0x6a, 0xa2, 0x6f, 0x57, 0x4d, 0xf4, 0xe6, 0x7b, 0x33, 0x03, 0x35, 0xc7, 0x9b, 0x74, 0xa8, 0x61, 0xce, 0x3b, 0xe6, 0x9c, 0xcd, 0xef, 0xd3, 0x3c, 0xfb, 0xdc, 0xf9, 0x11, 0x00, 0x00, 0xff, 0xff, 0xee, 0x30, 0x0c, 0x4a, 0x11, 0x06, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/enginepb/000077500000000000000000000000001421456440000166555ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/enginepb/enginepb.pb.go000066400000000000000000002155741421456440000214110ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: enginepb.proto package enginepb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" metapb "github.com/pingcap/kvproto/pkg/metapb" raft_cmdpb "github.com/pingcap/kvproto/pkg/raft_cmdpb" raft_serverpb "github.com/pingcap/kvproto/pkg/raft_serverpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type CommandRequestHeader struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` Term uint64 `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"` // Flush in-memory data to disk. SyncLog bool `protobuf:"varint,4,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` // Destroy the region. Destroy bool `protobuf:"varint,5,opt,name=destroy,proto3" json:"destroy,omitempty"` // Additional information for the request. Context []byte `protobuf:"bytes,6,opt,name=context,proto3" json:"context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandRequestHeader) Reset() { *m = CommandRequestHeader{} } func (m *CommandRequestHeader) String() string { return proto.CompactTextString(m) } func (*CommandRequestHeader) ProtoMessage() {} func (*CommandRequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{0} } func (m *CommandRequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandRequestHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandRequestHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandRequestHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandRequestHeader.Merge(dst, src) } func (m *CommandRequestHeader) XXX_Size() int { return m.Size() } func (m *CommandRequestHeader) XXX_DiscardUnknown() { xxx_messageInfo_CommandRequestHeader.DiscardUnknown(m) } var xxx_messageInfo_CommandRequestHeader proto.InternalMessageInfo func (m *CommandRequestHeader) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *CommandRequestHeader) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *CommandRequestHeader) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *CommandRequestHeader) GetSyncLog() bool { if m != nil { return m.SyncLog } return false } func (m *CommandRequestHeader) GetDestroy() bool { if m != nil { return m.Destroy } return false } func (m *CommandRequestHeader) GetContext() []byte { if m != nil { return m.Context } return nil } type CommandRequest struct { Header *CommandRequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // kv put / delete Requests []*raft_cmdpb.Request `protobuf:"bytes,2,rep,name=requests" json:"requests,omitempty"` // region metadata manipulation command. AdminRequest *raft_cmdpb.AdminRequest `protobuf:"bytes,3,opt,name=admin_request,json=adminRequest" json:"admin_request,omitempty"` // region metadata manipulation result. AdminResponse *raft_cmdpb.AdminResponse `protobuf:"bytes,4,opt,name=admin_response,json=adminResponse" json:"admin_response,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandRequest) Reset() { *m = CommandRequest{} } func (m *CommandRequest) String() string { return proto.CompactTextString(m) } func (*CommandRequest) ProtoMessage() {} func (*CommandRequest) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{1} } func (m *CommandRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandRequest.Merge(dst, src) } func (m *CommandRequest) XXX_Size() int { return m.Size() } func (m *CommandRequest) XXX_DiscardUnknown() { xxx_messageInfo_CommandRequest.DiscardUnknown(m) } var xxx_messageInfo_CommandRequest proto.InternalMessageInfo func (m *CommandRequest) GetHeader() *CommandRequestHeader { if m != nil { return m.Header } return nil } func (m *CommandRequest) GetRequests() []*raft_cmdpb.Request { if m != nil { return m.Requests } return nil } func (m *CommandRequest) GetAdminRequest() *raft_cmdpb.AdminRequest { if m != nil { return m.AdminRequest } return nil } func (m *CommandRequest) GetAdminResponse() *raft_cmdpb.AdminResponse { if m != nil { return m.AdminResponse } return nil } type CommandRequestBatch struct { Requests []*CommandRequest `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandRequestBatch) Reset() { *m = CommandRequestBatch{} } func (m *CommandRequestBatch) String() string { return proto.CompactTextString(m) } func (*CommandRequestBatch) ProtoMessage() {} func (*CommandRequestBatch) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{2} } func (m *CommandRequestBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandRequestBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandRequestBatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandRequestBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandRequestBatch.Merge(dst, src) } func (m *CommandRequestBatch) XXX_Size() int { return m.Size() } func (m *CommandRequestBatch) XXX_DiscardUnknown() { xxx_messageInfo_CommandRequestBatch.DiscardUnknown(m) } var xxx_messageInfo_CommandRequestBatch proto.InternalMessageInfo func (m *CommandRequestBatch) GetRequests() []*CommandRequest { if m != nil { return m.Requests } return nil } type CommandResponseHeader struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // Region is destroyed. Destroyed bool `protobuf:"varint,2,opt,name=destroyed,proto3" json:"destroyed,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandResponseHeader) Reset() { *m = CommandResponseHeader{} } func (m *CommandResponseHeader) String() string { return proto.CompactTextString(m) } func (*CommandResponseHeader) ProtoMessage() {} func (*CommandResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{3} } func (m *CommandResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandResponseHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandResponseHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandResponseHeader.Merge(dst, src) } func (m *CommandResponseHeader) XXX_Size() int { return m.Size() } func (m *CommandResponseHeader) XXX_DiscardUnknown() { xxx_messageInfo_CommandResponseHeader.DiscardUnknown(m) } var xxx_messageInfo_CommandResponseHeader proto.InternalMessageInfo func (m *CommandResponseHeader) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *CommandResponseHeader) GetDestroyed() bool { if m != nil { return m.Destroyed } return false } type CommandResponse struct { Header *CommandResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ApplyState *raft_serverpb.RaftApplyState `protobuf:"bytes,2,opt,name=apply_state,json=applyState" json:"apply_state,omitempty"` AppliedTerm uint64 `protobuf:"varint,3,opt,name=applied_term,json=appliedTerm,proto3" json:"applied_term,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandResponse) Reset() { *m = CommandResponse{} } func (m *CommandResponse) String() string { return proto.CompactTextString(m) } func (*CommandResponse) ProtoMessage() {} func (*CommandResponse) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{4} } func (m *CommandResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandResponse.Merge(dst, src) } func (m *CommandResponse) XXX_Size() int { return m.Size() } func (m *CommandResponse) XXX_DiscardUnknown() { xxx_messageInfo_CommandResponse.DiscardUnknown(m) } var xxx_messageInfo_CommandResponse proto.InternalMessageInfo func (m *CommandResponse) GetHeader() *CommandResponseHeader { if m != nil { return m.Header } return nil } func (m *CommandResponse) GetApplyState() *raft_serverpb.RaftApplyState { if m != nil { return m.ApplyState } return nil } func (m *CommandResponse) GetAppliedTerm() uint64 { if m != nil { return m.AppliedTerm } return 0 } type CommandResponseBatch struct { Responses []*CommandResponse `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommandResponseBatch) Reset() { *m = CommandResponseBatch{} } func (m *CommandResponseBatch) String() string { return proto.CompactTextString(m) } func (*CommandResponseBatch) ProtoMessage() {} func (*CommandResponseBatch) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{5} } func (m *CommandResponseBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommandResponseBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommandResponseBatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommandResponseBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_CommandResponseBatch.Merge(dst, src) } func (m *CommandResponseBatch) XXX_Size() int { return m.Size() } func (m *CommandResponseBatch) XXX_DiscardUnknown() { xxx_messageInfo_CommandResponseBatch.DiscardUnknown(m) } var xxx_messageInfo_CommandResponseBatch proto.InternalMessageInfo func (m *CommandResponseBatch) GetResponses() []*CommandResponse { if m != nil { return m.Responses } return nil } type SnapshotState struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` Peer *metapb.Peer `protobuf:"bytes,2,opt,name=peer" json:"peer,omitempty"` ApplyState *raft_serverpb.RaftApplyState `protobuf:"bytes,3,opt,name=apply_state,json=applyState" json:"apply_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotState) Reset() { *m = SnapshotState{} } func (m *SnapshotState) String() string { return proto.CompactTextString(m) } func (*SnapshotState) ProtoMessage() {} func (*SnapshotState) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{6} } func (m *SnapshotState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotState) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotState.Merge(dst, src) } func (m *SnapshotState) XXX_Size() int { return m.Size() } func (m *SnapshotState) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotState.DiscardUnknown(m) } var xxx_messageInfo_SnapshotState proto.InternalMessageInfo func (m *SnapshotState) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *SnapshotState) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *SnapshotState) GetApplyState() *raft_serverpb.RaftApplyState { if m != nil { return m.ApplyState } return nil } type SnapshotData struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Checksum uint32 `protobuf:"varint,2,opt,name=checksum,proto3" json:"checksum,omitempty"` Data []*raft_serverpb.KeyValue `protobuf:"bytes,3,rep,name=data" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotData) Reset() { *m = SnapshotData{} } func (m *SnapshotData) String() string { return proto.CompactTextString(m) } func (*SnapshotData) ProtoMessage() {} func (*SnapshotData) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{7} } func (m *SnapshotData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotData.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotData) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotData.Merge(dst, src) } func (m *SnapshotData) XXX_Size() int { return m.Size() } func (m *SnapshotData) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotData.DiscardUnknown(m) } var xxx_messageInfo_SnapshotData proto.InternalMessageInfo func (m *SnapshotData) GetCf() string { if m != nil { return m.Cf } return "" } func (m *SnapshotData) GetChecksum() uint32 { if m != nil { return m.Checksum } return 0 } func (m *SnapshotData) GetData() []*raft_serverpb.KeyValue { if m != nil { return m.Data } return nil } type SnapshotRequest struct { // Types that are valid to be assigned to Chunk: // *SnapshotRequest_State // *SnapshotRequest_Data Chunk isSnapshotRequest_Chunk `protobuf_oneof:"chunk"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotRequest) Reset() { *m = SnapshotRequest{} } func (m *SnapshotRequest) String() string { return proto.CompactTextString(m) } func (*SnapshotRequest) ProtoMessage() {} func (*SnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{8} } func (m *SnapshotRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotRequest.Merge(dst, src) } func (m *SnapshotRequest) XXX_Size() int { return m.Size() } func (m *SnapshotRequest) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotRequest.DiscardUnknown(m) } var xxx_messageInfo_SnapshotRequest proto.InternalMessageInfo type isSnapshotRequest_Chunk interface { isSnapshotRequest_Chunk() MarshalTo([]byte) (int, error) Size() int } type SnapshotRequest_State struct { State *SnapshotState `protobuf:"bytes,1,opt,name=state,oneof"` } type SnapshotRequest_Data struct { Data *SnapshotData `protobuf:"bytes,2,opt,name=data,oneof"` } func (*SnapshotRequest_State) isSnapshotRequest_Chunk() {} func (*SnapshotRequest_Data) isSnapshotRequest_Chunk() {} func (m *SnapshotRequest) GetChunk() isSnapshotRequest_Chunk { if m != nil { return m.Chunk } return nil } func (m *SnapshotRequest) GetState() *SnapshotState { if x, ok := m.GetChunk().(*SnapshotRequest_State); ok { return x.State } return nil } func (m *SnapshotRequest) GetData() *SnapshotData { if x, ok := m.GetChunk().(*SnapshotRequest_Data); ok { return x.Data } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*SnapshotRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _SnapshotRequest_OneofMarshaler, _SnapshotRequest_OneofUnmarshaler, _SnapshotRequest_OneofSizer, []interface{}{ (*SnapshotRequest_State)(nil), (*SnapshotRequest_Data)(nil), } } func _SnapshotRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*SnapshotRequest) // chunk switch x := m.Chunk.(type) { case *SnapshotRequest_State: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.State); err != nil { return err } case *SnapshotRequest_Data: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Data); err != nil { return err } case nil: default: return fmt.Errorf("SnapshotRequest.Chunk has unexpected type %T", x) } return nil } func _SnapshotRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*SnapshotRequest) switch tag { case 1: // chunk.state if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(SnapshotState) err := b.DecodeMessage(msg) m.Chunk = &SnapshotRequest_State{msg} return true, err case 2: // chunk.data if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(SnapshotData) err := b.DecodeMessage(msg) m.Chunk = &SnapshotRequest_Data{msg} return true, err default: return false, nil } } func _SnapshotRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*SnapshotRequest) // chunk switch x := m.Chunk.(type) { case *SnapshotRequest_State: s := proto.Size(x.State) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *SnapshotRequest_Data: s := proto.Size(x.Data) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type SnapshotDone struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotDone) Reset() { *m = SnapshotDone{} } func (m *SnapshotDone) String() string { return proto.CompactTextString(m) } func (*SnapshotDone) ProtoMessage() {} func (*SnapshotDone) Descriptor() ([]byte, []int) { return fileDescriptor_enginepb_3d26096a0d74b990, []int{9} } func (m *SnapshotDone) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotDone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotDone.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotDone) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotDone.Merge(dst, src) } func (m *SnapshotDone) XXX_Size() int { return m.Size() } func (m *SnapshotDone) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotDone.DiscardUnknown(m) } var xxx_messageInfo_SnapshotDone proto.InternalMessageInfo func init() { proto.RegisterType((*CommandRequestHeader)(nil), "enginepb.CommandRequestHeader") proto.RegisterType((*CommandRequest)(nil), "enginepb.CommandRequest") proto.RegisterType((*CommandRequestBatch)(nil), "enginepb.CommandRequestBatch") proto.RegisterType((*CommandResponseHeader)(nil), "enginepb.CommandResponseHeader") proto.RegisterType((*CommandResponse)(nil), "enginepb.CommandResponse") proto.RegisterType((*CommandResponseBatch)(nil), "enginepb.CommandResponseBatch") proto.RegisterType((*SnapshotState)(nil), "enginepb.SnapshotState") proto.RegisterType((*SnapshotData)(nil), "enginepb.SnapshotData") proto.RegisterType((*SnapshotRequest)(nil), "enginepb.SnapshotRequest") proto.RegisterType((*SnapshotDone)(nil), "enginepb.SnapshotDone") } // 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 // Client API for Engine service type EngineClient interface { ApplyCommandBatch(ctx context.Context, opts ...grpc.CallOption) (Engine_ApplyCommandBatchClient, error) ApplySnapshot(ctx context.Context, opts ...grpc.CallOption) (Engine_ApplySnapshotClient, error) } type engineClient struct { cc *grpc.ClientConn } func NewEngineClient(cc *grpc.ClientConn) EngineClient { return &engineClient{cc} } func (c *engineClient) ApplyCommandBatch(ctx context.Context, opts ...grpc.CallOption) (Engine_ApplyCommandBatchClient, error) { stream, err := c.cc.NewStream(ctx, &_Engine_serviceDesc.Streams[0], "/enginepb.Engine/ApplyCommandBatch", opts...) if err != nil { return nil, err } x := &engineApplyCommandBatchClient{stream} return x, nil } type Engine_ApplyCommandBatchClient interface { Send(*CommandRequestBatch) error Recv() (*CommandResponseBatch, error) grpc.ClientStream } type engineApplyCommandBatchClient struct { grpc.ClientStream } func (x *engineApplyCommandBatchClient) Send(m *CommandRequestBatch) error { return x.ClientStream.SendMsg(m) } func (x *engineApplyCommandBatchClient) Recv() (*CommandResponseBatch, error) { m := new(CommandResponseBatch) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *engineClient) ApplySnapshot(ctx context.Context, opts ...grpc.CallOption) (Engine_ApplySnapshotClient, error) { stream, err := c.cc.NewStream(ctx, &_Engine_serviceDesc.Streams[1], "/enginepb.Engine/ApplySnapshot", opts...) if err != nil { return nil, err } x := &engineApplySnapshotClient{stream} return x, nil } type Engine_ApplySnapshotClient interface { Send(*SnapshotRequest) error CloseAndRecv() (*SnapshotDone, error) grpc.ClientStream } type engineApplySnapshotClient struct { grpc.ClientStream } func (x *engineApplySnapshotClient) Send(m *SnapshotRequest) error { return x.ClientStream.SendMsg(m) } func (x *engineApplySnapshotClient) CloseAndRecv() (*SnapshotDone, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(SnapshotDone) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for Engine service type EngineServer interface { ApplyCommandBatch(Engine_ApplyCommandBatchServer) error ApplySnapshot(Engine_ApplySnapshotServer) error } func RegisterEngineServer(s *grpc.Server, srv EngineServer) { s.RegisterService(&_Engine_serviceDesc, srv) } func _Engine_ApplyCommandBatch_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(EngineServer).ApplyCommandBatch(&engineApplyCommandBatchServer{stream}) } type Engine_ApplyCommandBatchServer interface { Send(*CommandResponseBatch) error Recv() (*CommandRequestBatch, error) grpc.ServerStream } type engineApplyCommandBatchServer struct { grpc.ServerStream } func (x *engineApplyCommandBatchServer) Send(m *CommandResponseBatch) error { return x.ServerStream.SendMsg(m) } func (x *engineApplyCommandBatchServer) Recv() (*CommandRequestBatch, error) { m := new(CommandRequestBatch) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Engine_ApplySnapshot_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(EngineServer).ApplySnapshot(&engineApplySnapshotServer{stream}) } type Engine_ApplySnapshotServer interface { SendAndClose(*SnapshotDone) error Recv() (*SnapshotRequest, error) grpc.ServerStream } type engineApplySnapshotServer struct { grpc.ServerStream } func (x *engineApplySnapshotServer) SendAndClose(m *SnapshotDone) error { return x.ServerStream.SendMsg(m) } func (x *engineApplySnapshotServer) Recv() (*SnapshotRequest, error) { m := new(SnapshotRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } var _Engine_serviceDesc = grpc.ServiceDesc{ ServiceName: "enginepb.Engine", HandlerType: (*EngineServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "ApplyCommandBatch", Handler: _Engine_ApplyCommandBatch_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "ApplySnapshot", Handler: _Engine_ApplySnapshot_Handler, ClientStreams: true, }, }, Metadata: "enginepb.proto", } func (m *CommandRequestHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandRequestHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.RegionId)) } if m.Index != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Index)) } if m.Term != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Term)) } if m.SyncLog { dAtA[i] = 0x20 i++ if m.SyncLog { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.Destroy { dAtA[i] = 0x28 i++ if m.Destroy { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Context) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintEnginepb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommandRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Header.Size())) n1, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if len(m.Requests) > 0 { for _, msg := range m.Requests { dAtA[i] = 0x12 i++ i = encodeVarintEnginepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.AdminRequest != nil { dAtA[i] = 0x1a i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.AdminRequest.Size())) n2, err := m.AdminRequest.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.AdminResponse != nil { dAtA[i] = 0x22 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.AdminResponse.Size())) n3, err := m.AdminResponse.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommandRequestBatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandRequestBatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Requests) > 0 { for _, msg := range m.Requests { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommandResponseHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandResponseHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.RegionId)) } if m.Destroyed { dAtA[i] = 0x10 i++ if m.Destroyed { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommandResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Header.Size())) n4, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.ApplyState != nil { dAtA[i] = 0x12 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.ApplyState.Size())) n5, err := m.ApplyState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.AppliedTerm != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.AppliedTerm)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommandResponseBatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommandResponseBatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Responses) > 0 { for _, msg := range m.Responses { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Region.Size())) n6, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.Peer != nil { dAtA[i] = 0x12 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Peer.Size())) n7, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.ApplyState != nil { dAtA[i] = 0x1a i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.ApplyState.Size())) n8, err := m.ApplyState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotData) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Checksum != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Checksum)) } if len(m.Data) > 0 { for _, msg := range m.Data { dAtA[i] = 0x1a i++ i = encodeVarintEnginepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Chunk != nil { nn9, err := m.Chunk.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn9 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotRequest_State) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.State != nil { dAtA[i] = 0xa i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.State.Size())) n10, err := m.State.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } return i, nil } func (m *SnapshotRequest_Data) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Data != nil { dAtA[i] = 0x12 i++ i = encodeVarintEnginepb(dAtA, i, uint64(m.Data.Size())) n11, err := m.Data.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } return i, nil } func (m *SnapshotDone) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotDone) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintEnginepb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *CommandRequestHeader) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovEnginepb(uint64(m.RegionId)) } if m.Index != 0 { n += 1 + sovEnginepb(uint64(m.Index)) } if m.Term != 0 { n += 1 + sovEnginepb(uint64(m.Term)) } if m.SyncLog { n += 2 } if m.Destroy { n += 2 } l = len(m.Context) if l > 0 { n += 1 + l + sovEnginepb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommandRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovEnginepb(uint64(l)) } if len(m.Requests) > 0 { for _, e := range m.Requests { l = e.Size() n += 1 + l + sovEnginepb(uint64(l)) } } if m.AdminRequest != nil { l = m.AdminRequest.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.AdminResponse != nil { l = m.AdminResponse.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommandRequestBatch) Size() (n int) { var l int _ = l if len(m.Requests) > 0 { for _, e := range m.Requests { l = e.Size() n += 1 + l + sovEnginepb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommandResponseHeader) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovEnginepb(uint64(m.RegionId)) } if m.Destroyed { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommandResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.ApplyState != nil { l = m.ApplyState.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.AppliedTerm != 0 { n += 1 + sovEnginepb(uint64(m.AppliedTerm)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommandResponseBatch) Size() (n int) { var l int _ = l if len(m.Responses) > 0 { for _, e := range m.Responses { l = e.Size() n += 1 + l + sovEnginepb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotState) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.ApplyState != nil { l = m.ApplyState.Size() n += 1 + l + sovEnginepb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotData) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovEnginepb(uint64(l)) } if m.Checksum != 0 { n += 1 + sovEnginepb(uint64(m.Checksum)) } if len(m.Data) > 0 { for _, e := range m.Data { l = e.Size() n += 1 + l + sovEnginepb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotRequest) Size() (n int) { var l int _ = l if m.Chunk != nil { n += m.Chunk.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotRequest_State) Size() (n int) { var l int _ = l if m.State != nil { l = m.State.Size() n += 1 + l + sovEnginepb(uint64(l)) } return n } func (m *SnapshotRequest_Data) Size() (n int) { var l int _ = l if m.Data != nil { l = m.Data.Size() n += 1 + l + sovEnginepb(uint64(l)) } return n } func (m *SnapshotDone) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovEnginepb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozEnginepb(x uint64) (n int) { return sovEnginepb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *CommandRequestHeader) 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 ErrIntOverflowEnginepb } 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: CommandRequestHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandRequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SyncLog = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Destroy", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Destroy = bool(v != 0) case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *CommandRequest) 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 ErrIntOverflowEnginepb } 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: CommandRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &CommandRequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Requests = append(m.Requests, &raft_cmdpb.Request{}) if err := m.Requests[len(m.Requests)-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 AdminRequest", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminRequest == nil { m.AdminRequest = &raft_cmdpb.AdminRequest{} } if err := m.AdminRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AdminResponse", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminResponse == nil { m.AdminResponse = &raft_cmdpb.AdminResponse{} } if err := m.AdminResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *CommandRequestBatch) 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 ErrIntOverflowEnginepb } 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: CommandRequestBatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandRequestBatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Requests = append(m.Requests, &CommandRequest{}) if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *CommandResponseHeader) 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 ErrIntOverflowEnginepb } 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: CommandResponseHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Destroyed", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Destroyed = bool(v != 0) default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *CommandResponse) 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 ErrIntOverflowEnginepb } 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: CommandResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &CommandResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ApplyState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ApplyState == nil { m.ApplyState = &raft_serverpb.RaftApplyState{} } if err := m.ApplyState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AppliedTerm", wireType) } m.AppliedTerm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AppliedTerm |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *CommandResponseBatch) 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 ErrIntOverflowEnginepb } 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: CommandResponseBatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommandResponseBatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Responses = append(m.Responses, &CommandResponse{}) if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *SnapshotState) 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 ErrIntOverflowEnginepb } 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: SnapshotState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ApplyState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ApplyState == nil { m.ApplyState = &raft_serverpb.RaftApplyState{} } if err := m.ApplyState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *SnapshotData) 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 ErrIntOverflowEnginepb } 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: SnapshotData: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotData: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } 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 ErrInvalidLengthEnginepb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType) } m.Checksum = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Checksum |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } 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 ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data, &raft_serverpb.KeyValue{}) if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *SnapshotRequest) 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 ErrIntOverflowEnginepb } 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: SnapshotRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &SnapshotState{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &SnapshotRequest_State{v} iNdEx = postIndex case 2: 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 ErrIntOverflowEnginepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEnginepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &SnapshotData{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &SnapshotRequest_Data{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 *SnapshotDone) 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 ErrIntOverflowEnginepb } 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: SnapshotDone: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotDone: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipEnginepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEnginepb } 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 skipEnginepb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEnginepb } 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, ErrIntOverflowEnginepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEnginepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthEnginepb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEnginepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipEnginepb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthEnginepb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowEnginepb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("enginepb.proto", fileDescriptor_enginepb_3d26096a0d74b990) } var fileDescriptor_enginepb_3d26096a0d74b990 = []byte{ // 681 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, 0x14, 0xcd, 0xe4, 0xaf, 0xe9, 0x75, 0x92, 0xf6, 0x9b, 0xf6, 0xa3, 0x4e, 0xa0, 0x21, 0x78, 0x81, 0x22, 0x81, 0x52, 0x14, 0x10, 0x5d, 0x81, 0x68, 0xf9, 0x51, 0x51, 0x91, 0x40, 0x53, 0x84, 0xd8, 0x45, 0x53, 0xfb, 0xe6, 0x47, 0xad, 0x7f, 0xb0, 0x27, 0xa8, 0x79, 0x13, 0x78, 0x05, 0x04, 0xef, 0xc1, 0x92, 0x47, 0x40, 0xe5, 0x2d, 0x58, 0x21, 0xcf, 0x8c, 0x1d, 0x27, 0x4d, 0x24, 0xd8, 0xe5, 0x9e, 0x7b, 0x66, 0xee, 0x39, 0xe7, 0x8e, 0x03, 0x75, 0xf4, 0x86, 0x63, 0x0f, 0x83, 0xd3, 0x6e, 0x10, 0xfa, 0xc2, 0xa7, 0x95, 0xa4, 0x6e, 0x56, 0x5d, 0x14, 0x3c, 0xc1, 0x9b, 0x9b, 0x21, 0x1f, 0x88, 0xbe, 0xed, 0x3a, 0x29, 0xb2, 0x25, 0x91, 0x08, 0xc3, 0x8f, 0x18, 0x26, 0xa0, 0xf5, 0x95, 0xc0, 0xf6, 0x53, 0xdf, 0x75, 0xb9, 0xe7, 0x30, 0xfc, 0x30, 0xc1, 0x48, 0x1c, 0x21, 0x77, 0x30, 0xa4, 0xd7, 0x61, 0x3d, 0xc4, 0xe1, 0xd8, 0xf7, 0xfa, 0x63, 0xc7, 0x24, 0x6d, 0xd2, 0x29, 0xb2, 0x8a, 0x02, 0x5e, 0x3a, 0x74, 0x1b, 0x4a, 0x63, 0xcf, 0xc1, 0x0b, 0x33, 0x2f, 0x1b, 0xaa, 0xa0, 0x14, 0x8a, 0x02, 0x43, 0xd7, 0x2c, 0x48, 0x50, 0xfe, 0xa6, 0x0d, 0xa8, 0x44, 0x53, 0xcf, 0xee, 0x9f, 0xfb, 0x43, 0xb3, 0xd8, 0x26, 0x9d, 0x0a, 0x5b, 0x8b, 0xeb, 0x57, 0xfe, 0x90, 0x9a, 0xb0, 0xe6, 0x60, 0x24, 0x42, 0x7f, 0x6a, 0x96, 0x54, 0x47, 0x97, 0x71, 0xc7, 0xf6, 0x3d, 0x81, 0x17, 0xc2, 0x2c, 0xb7, 0x49, 0xa7, 0xca, 0x92, 0xd2, 0xfa, 0x4d, 0xa0, 0x3e, 0x2f, 0x97, 0x3e, 0x84, 0xf2, 0x48, 0x4a, 0x96, 0x2a, 0x8d, 0x5e, 0xab, 0x9b, 0x26, 0xb4, 0xcc, 0x18, 0xd3, 0x6c, 0xba, 0x07, 0x95, 0x50, 0x35, 0x22, 0x33, 0xdf, 0x2e, 0x74, 0x8c, 0xde, 0x56, 0x37, 0x93, 0x99, 0x3e, 0xc4, 0x52, 0x12, 0x7d, 0x04, 0x35, 0xee, 0xb8, 0x63, 0xaf, 0xaf, 0x11, 0xe9, 0xd3, 0xe8, 0x99, 0xd9, 0x53, 0x07, 0x31, 0x21, 0x39, 0x5a, 0xe5, 0x99, 0x8a, 0x3e, 0x81, 0x7a, 0x72, 0x3c, 0x0a, 0x7c, 0x2f, 0x42, 0x99, 0x87, 0xd1, 0x6b, 0x2c, 0x39, 0xaf, 0x08, 0xac, 0xc6, 0xb3, 0xa5, 0x75, 0x0c, 0x5b, 0xf3, 0x8e, 0x0e, 0xb9, 0xb0, 0x47, 0xf4, 0x41, 0xc6, 0x08, 0x91, 0x46, 0xcc, 0x55, 0x11, 0xcc, 0xdc, 0x58, 0x0c, 0xfe, 0x4f, 0x7b, 0xea, 0xfe, 0xbf, 0x59, 0xfc, 0x0d, 0x58, 0xd7, 0x4b, 0x42, 0x47, 0x2e, 0xbf, 0xc2, 0x66, 0x80, 0xf5, 0x8d, 0xc0, 0xc6, 0xc2, 0xa5, 0x74, 0x7f, 0x61, 0x3d, 0x37, 0x97, 0x68, 0xcb, 0xce, 0x4f, 0xf7, 0xf3, 0x18, 0x0c, 0x1e, 0x04, 0xe7, 0xd3, 0x7e, 0x24, 0xb8, 0x40, 0x39, 0xcc, 0xe8, 0xed, 0x76, 0xe7, 0x1f, 0x31, 0xe3, 0x03, 0x71, 0x10, 0xb3, 0x4e, 0x62, 0x12, 0x03, 0x9e, 0xfe, 0xa6, 0xb7, 0xa0, 0x1a, 0x57, 0x63, 0x74, 0xfa, 0x99, 0x57, 0x69, 0x68, 0xec, 0x2d, 0x86, 0xae, 0xf5, 0x3a, 0xf3, 0xf6, 0x95, 0x06, 0x95, 0xe8, 0x7e, 0x1c, 0x81, 0x02, 0x92, 0x48, 0x1b, 0x2b, 0x65, 0xb3, 0x19, 0xd7, 0xfa, 0x4c, 0xa0, 0x76, 0xe2, 0xf1, 0x20, 0x1a, 0xf9, 0x42, 0xa9, 0xb8, 0x0d, 0x65, 0x15, 0x9e, 0xb6, 0x5f, 0xef, 0xea, 0xaf, 0x94, 0x49, 0x94, 0xe9, 0x2e, 0x6d, 0x43, 0x31, 0x40, 0x0c, 0xb5, 0xcd, 0x6a, 0xc2, 0x7a, 0x83, 0x18, 0x32, 0xd9, 0x59, 0xcc, 0xa3, 0xf0, 0x8f, 0x79, 0x58, 0x43, 0xa8, 0x26, 0xd2, 0x9e, 0x71, 0xc1, 0x69, 0x1d, 0xf2, 0xf6, 0x40, 0xaa, 0x5a, 0x67, 0x79, 0x7b, 0x40, 0x9b, 0x50, 0xb1, 0x47, 0x68, 0x9f, 0x45, 0x13, 0x57, 0xaa, 0xa8, 0xb1, 0xb4, 0xa6, 0x77, 0xa0, 0xe8, 0x70, 0xc1, 0xcd, 0x82, 0xcc, 0x62, 0x67, 0x61, 0xe8, 0x31, 0x4e, 0xdf, 0xf1, 0xf3, 0x09, 0x32, 0x49, 0xb2, 0xa6, 0xb0, 0x91, 0x0c, 0x4a, 0xde, 0xfe, 0x1e, 0x94, 0x94, 0x6a, 0x15, 0xc2, 0xce, 0x2c, 0xcc, 0xb9, 0xb4, 0x8e, 0x72, 0x4c, 0xf1, 0xe8, 0x5d, 0x3d, 0x50, 0xc5, 0x71, 0xed, 0x2a, 0x3f, 0xb6, 0x70, 0x94, 0x53, 0x13, 0x0f, 0xd7, 0xa0, 0x64, 0x8f, 0x26, 0xde, 0x99, 0x55, 0xcf, 0x78, 0xf4, 0x3d, 0xec, 0x7d, 0x21, 0x50, 0x7e, 0x2e, 0x8f, 0xd2, 0xf7, 0xf0, 0x9f, 0x0c, 0x46, 0x6f, 0x4f, 0x2d, 0x7a, 0x77, 0xd5, 0x87, 0x22, 0xdb, 0xcd, 0xd6, 0xca, 0xa5, 0xcb, 0xbe, 0x95, 0xeb, 0x90, 0x7b, 0x84, 0xbe, 0x80, 0x9a, 0x8a, 0x5c, 0x4f, 0xa6, 0x8d, 0xab, 0x72, 0xf5, 0xb5, 0xcd, 0x65, 0x4e, 0x7c, 0x0f, 0xe3, 0x9b, 0x0e, 0x37, 0xbf, 0x5f, 0xb6, 0xc8, 0x8f, 0xcb, 0x16, 0xf9, 0x79, 0xd9, 0x22, 0x9f, 0x7e, 0xb5, 0x72, 0xa7, 0x65, 0xf9, 0x1f, 0x7d, 0xff, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xc9, 0x50, 0xee, 0xf4, 0x05, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/eraftpb/000077500000000000000000000000001421456440000165115ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/eraftpb/eraftpb.pb.go000066400000000000000000002473051421456440000210760ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: eraftpb.proto package eraftpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type EntryType int32 const ( EntryType_EntryNormal EntryType = 0 EntryType_EntryConfChange EntryType = 1 EntryType_EntryConfChangeV2 EntryType = 2 ) var EntryType_name = map[int32]string{ 0: "EntryNormal", 1: "EntryConfChange", 2: "EntryConfChangeV2", } var EntryType_value = map[string]int32{ "EntryNormal": 0, "EntryConfChange": 1, "EntryConfChangeV2": 2, } func (x EntryType) String() string { return proto.EnumName(EntryType_name, int32(x)) } func (EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{0} } type MessageType int32 const ( MessageType_MsgHup MessageType = 0 MessageType_MsgBeat MessageType = 1 MessageType_MsgPropose MessageType = 2 MessageType_MsgAppend MessageType = 3 MessageType_MsgAppendResponse MessageType = 4 MessageType_MsgRequestVote MessageType = 5 MessageType_MsgRequestVoteResponse MessageType = 6 MessageType_MsgSnapshot MessageType = 7 MessageType_MsgHeartbeat MessageType = 8 MessageType_MsgHeartbeatResponse MessageType = 9 MessageType_MsgUnreachable MessageType = 10 MessageType_MsgSnapStatus MessageType = 11 MessageType_MsgCheckQuorum MessageType = 12 MessageType_MsgTransferLeader MessageType = 13 MessageType_MsgTimeoutNow MessageType = 14 MessageType_MsgReadIndex MessageType = 15 MessageType_MsgReadIndexResp MessageType = 16 MessageType_MsgRequestPreVote MessageType = 17 MessageType_MsgRequestPreVoteResponse MessageType = 18 ) var MessageType_name = map[int32]string{ 0: "MsgHup", 1: "MsgBeat", 2: "MsgPropose", 3: "MsgAppend", 4: "MsgAppendResponse", 5: "MsgRequestVote", 6: "MsgRequestVoteResponse", 7: "MsgSnapshot", 8: "MsgHeartbeat", 9: "MsgHeartbeatResponse", 10: "MsgUnreachable", 11: "MsgSnapStatus", 12: "MsgCheckQuorum", 13: "MsgTransferLeader", 14: "MsgTimeoutNow", 15: "MsgReadIndex", 16: "MsgReadIndexResp", 17: "MsgRequestPreVote", 18: "MsgRequestPreVoteResponse", } var MessageType_value = map[string]int32{ "MsgHup": 0, "MsgBeat": 1, "MsgPropose": 2, "MsgAppend": 3, "MsgAppendResponse": 4, "MsgRequestVote": 5, "MsgRequestVoteResponse": 6, "MsgSnapshot": 7, "MsgHeartbeat": 8, "MsgHeartbeatResponse": 9, "MsgUnreachable": 10, "MsgSnapStatus": 11, "MsgCheckQuorum": 12, "MsgTransferLeader": 13, "MsgTimeoutNow": 14, "MsgReadIndex": 15, "MsgReadIndexResp": 16, "MsgRequestPreVote": 17, "MsgRequestPreVoteResponse": 18, } func (x MessageType) String() string { return proto.EnumName(MessageType_name, int32(x)) } func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{1} } type ConfChangeTransition int32 const ( // Automatically use the simple protocol if possible, otherwise fall back // to ConfChangeType::Implicit. Most applications will want to use this. ConfChangeTransition_Auto ConfChangeTransition = 0 // Use joint consensus unconditionally, and transition out of them // automatically (by proposing a zero configuration change). // // This option is suitable for applications that want to minimize the time // spent in the joint configuration and do not store the joint configuration // in the state machine (outside of InitialState). ConfChangeTransition_Implicit ConfChangeTransition = 1 // Use joint consensus and remain in the joint configuration until the // application proposes a no-op configuration change. This is suitable for // applications that want to explicitly control the transitions, for example // to use a custom payload (via the Context field). ConfChangeTransition_Explicit ConfChangeTransition = 2 ) var ConfChangeTransition_name = map[int32]string{ 0: "Auto", 1: "Implicit", 2: "Explicit", } var ConfChangeTransition_value = map[string]int32{ "Auto": 0, "Implicit": 1, "Explicit": 2, } func (x ConfChangeTransition) String() string { return proto.EnumName(ConfChangeTransition_name, int32(x)) } func (ConfChangeTransition) EnumDescriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{2} } type ConfChangeType int32 const ( ConfChangeType_AddNode ConfChangeType = 0 ConfChangeType_RemoveNode ConfChangeType = 1 ConfChangeType_AddLearnerNode ConfChangeType = 2 ) var ConfChangeType_name = map[int32]string{ 0: "AddNode", 1: "RemoveNode", 2: "AddLearnerNode", } var ConfChangeType_value = map[string]int32{ "AddNode": 0, "RemoveNode": 1, "AddLearnerNode": 2, } func (x ConfChangeType) String() string { return proto.EnumName(ConfChangeType_name, int32(x)) } func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{3} } // The entry is a type of change that needs to be applied. It contains two data fields. // While the fields are built into the model; their usage is determined by the entry_type. // // For normal entries, the data field should contain the data change that should be applied. // The context field can be used for any contextual data that might be relevant to the // application of the data. // // For configuration changes, the data will contain the ConfChange message and the // context will provide anything needed to assist the configuration change. The context // if for the user to set and use in this case. type Entry struct { EntryType EntryType `protobuf:"varint,1,opt,name=entry_type,json=entryType,proto3,enum=eraftpb.EntryType" json:"entry_type,omitempty"` Term uint64 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"` Index uint64 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` Context []byte `protobuf:"bytes,6,opt,name=context,proto3" json:"context,omitempty"` // Deprecated! It is kept for backward compatibility. // TODO: remove it in the next major release. SyncLog bool `protobuf:"varint,5,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Entry) Reset() { *m = Entry{} } func (m *Entry) String() string { return proto.CompactTextString(m) } func (*Entry) ProtoMessage() {} func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{0} } func (m *Entry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Entry.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Entry) XXX_Merge(src proto.Message) { xxx_messageInfo_Entry.Merge(dst, src) } func (m *Entry) XXX_Size() int { return m.Size() } func (m *Entry) XXX_DiscardUnknown() { xxx_messageInfo_Entry.DiscardUnknown(m) } var xxx_messageInfo_Entry proto.InternalMessageInfo func (m *Entry) GetEntryType() EntryType { if m != nil { return m.EntryType } return EntryType_EntryNormal } func (m *Entry) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *Entry) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *Entry) GetData() []byte { if m != nil { return m.Data } return nil } func (m *Entry) GetContext() []byte { if m != nil { return m.Context } return nil } func (m *Entry) GetSyncLog() bool { if m != nil { return m.SyncLog } return false } type SnapshotMetadata struct { // The current `ConfState`. ConfState *ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state,omitempty"` // The applied index. Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` // The term of the applied index. Term uint64 `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotMetadata) Reset() { *m = SnapshotMetadata{} } func (m *SnapshotMetadata) String() string { return proto.CompactTextString(m) } func (*SnapshotMetadata) ProtoMessage() {} func (*SnapshotMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{1} } func (m *SnapshotMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotMetadata.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotMetadata.Merge(dst, src) } func (m *SnapshotMetadata) XXX_Size() int { return m.Size() } func (m *SnapshotMetadata) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotMetadata.DiscardUnknown(m) } var xxx_messageInfo_SnapshotMetadata proto.InternalMessageInfo func (m *SnapshotMetadata) GetConfState() *ConfState { if m != nil { return m.ConfState } return nil } func (m *SnapshotMetadata) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *SnapshotMetadata) GetTerm() uint64 { if m != nil { return m.Term } return 0 } type Snapshot struct { Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` Metadata *SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Snapshot) Reset() { *m = Snapshot{} } func (m *Snapshot) String() string { return proto.CompactTextString(m) } func (*Snapshot) ProtoMessage() {} func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{2} } func (m *Snapshot) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Snapshot) XXX_Merge(src proto.Message) { xxx_messageInfo_Snapshot.Merge(dst, src) } func (m *Snapshot) XXX_Size() int { return m.Size() } func (m *Snapshot) XXX_DiscardUnknown() { xxx_messageInfo_Snapshot.DiscardUnknown(m) } var xxx_messageInfo_Snapshot proto.InternalMessageInfo func (m *Snapshot) GetData() []byte { if m != nil { return m.Data } return nil } func (m *Snapshot) GetMetadata() *SnapshotMetadata { if m != nil { return m.Metadata } return nil } type Message struct { MsgType MessageType `protobuf:"varint,1,opt,name=msg_type,json=msgType,proto3,enum=eraftpb.MessageType" json:"msg_type,omitempty"` To uint64 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"` From uint64 `protobuf:"varint,3,opt,name=from,proto3" json:"from,omitempty"` Term uint64 `protobuf:"varint,4,opt,name=term,proto3" json:"term,omitempty"` LogTerm uint64 `protobuf:"varint,5,opt,name=log_term,json=logTerm,proto3" json:"log_term,omitempty"` Index uint64 `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"` Entries []*Entry `protobuf:"bytes,7,rep,name=entries" json:"entries,omitempty"` Commit uint64 `protobuf:"varint,8,opt,name=commit,proto3" json:"commit,omitempty"` Snapshot *Snapshot `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot,omitempty"` RequestSnapshot uint64 `protobuf:"varint,13,opt,name=request_snapshot,json=requestSnapshot,proto3" json:"request_snapshot,omitempty"` Reject bool `protobuf:"varint,10,opt,name=reject,proto3" json:"reject,omitempty"` RejectHint uint64 `protobuf:"varint,11,opt,name=reject_hint,json=rejectHint,proto3" json:"reject_hint,omitempty"` Context []byte `protobuf:"bytes,12,opt,name=context,proto3" json:"context,omitempty"` Priority uint64 `protobuf:"varint,14,opt,name=priority,proto3" json:"priority,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Message) Reset() { *m = Message{} } func (m *Message) String() string { return proto.CompactTextString(m) } func (*Message) ProtoMessage() {} func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{3} } func (m *Message) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Message.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Message) XXX_Merge(src proto.Message) { xxx_messageInfo_Message.Merge(dst, src) } func (m *Message) XXX_Size() int { return m.Size() } func (m *Message) XXX_DiscardUnknown() { xxx_messageInfo_Message.DiscardUnknown(m) } var xxx_messageInfo_Message proto.InternalMessageInfo func (m *Message) GetMsgType() MessageType { if m != nil { return m.MsgType } return MessageType_MsgHup } func (m *Message) GetTo() uint64 { if m != nil { return m.To } return 0 } func (m *Message) GetFrom() uint64 { if m != nil { return m.From } return 0 } func (m *Message) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *Message) GetLogTerm() uint64 { if m != nil { return m.LogTerm } return 0 } func (m *Message) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *Message) GetEntries() []*Entry { if m != nil { return m.Entries } return nil } func (m *Message) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } func (m *Message) GetSnapshot() *Snapshot { if m != nil { return m.Snapshot } return nil } func (m *Message) GetRequestSnapshot() uint64 { if m != nil { return m.RequestSnapshot } return 0 } func (m *Message) GetReject() bool { if m != nil { return m.Reject } return false } func (m *Message) GetRejectHint() uint64 { if m != nil { return m.RejectHint } return 0 } func (m *Message) GetContext() []byte { if m != nil { return m.Context } return nil } func (m *Message) GetPriority() uint64 { if m != nil { return m.Priority } return 0 } type HardState struct { Term uint64 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"` Vote uint64 `protobuf:"varint,2,opt,name=vote,proto3" json:"vote,omitempty"` Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *HardState) Reset() { *m = HardState{} } func (m *HardState) String() string { return proto.CompactTextString(m) } func (*HardState) ProtoMessage() {} func (*HardState) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{4} } func (m *HardState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *HardState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_HardState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *HardState) XXX_Merge(src proto.Message) { xxx_messageInfo_HardState.Merge(dst, src) } func (m *HardState) XXX_Size() int { return m.Size() } func (m *HardState) XXX_DiscardUnknown() { xxx_messageInfo_HardState.DiscardUnknown(m) } var xxx_messageInfo_HardState proto.InternalMessageInfo func (m *HardState) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *HardState) GetVote() uint64 { if m != nil { return m.Vote } return 0 } func (m *HardState) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } type ConfState struct { Voters []uint64 `protobuf:"varint,1,rep,packed,name=voters" json:"voters,omitempty"` Learners []uint64 `protobuf:"varint,2,rep,packed,name=learners" json:"learners,omitempty"` // The voters in the outgoing config. If not empty the node is in joint consensus. VotersOutgoing []uint64 `protobuf:"varint,3,rep,packed,name=voters_outgoing,json=votersOutgoing" json:"voters_outgoing,omitempty"` // The nodes that will become learners when the outgoing config is removed. // These nodes are necessarily currently in nodes_joint (or they would have // been added to the incoming config right away). LearnersNext []uint64 `protobuf:"varint,4,rep,packed,name=learners_next,json=learnersNext" json:"learners_next,omitempty"` // If set, the config is joint and Raft will automatically transition into // the final config (i.e. remove the outgoing config) when this is safe. AutoLeave bool `protobuf:"varint,5,opt,name=auto_leave,json=autoLeave,proto3" json:"auto_leave,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfState) Reset() { *m = ConfState{} } func (m *ConfState) String() string { return proto.CompactTextString(m) } func (*ConfState) ProtoMessage() {} func (*ConfState) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{5} } func (m *ConfState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfState) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfState.Merge(dst, src) } func (m *ConfState) XXX_Size() int { return m.Size() } func (m *ConfState) XXX_DiscardUnknown() { xxx_messageInfo_ConfState.DiscardUnknown(m) } var xxx_messageInfo_ConfState proto.InternalMessageInfo func (m *ConfState) GetVoters() []uint64 { if m != nil { return m.Voters } return nil } func (m *ConfState) GetLearners() []uint64 { if m != nil { return m.Learners } return nil } func (m *ConfState) GetVotersOutgoing() []uint64 { if m != nil { return m.VotersOutgoing } return nil } func (m *ConfState) GetLearnersNext() []uint64 { if m != nil { return m.LearnersNext } return nil } func (m *ConfState) GetAutoLeave() bool { if m != nil { return m.AutoLeave } return false } type ConfChange struct { ChangeType ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` NodeId uint64 `protobuf:"varint,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` Context []byte `protobuf:"bytes,4,opt,name=context,proto3" json:"context,omitempty"` Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfChange) Reset() { *m = ConfChange{} } func (m *ConfChange) String() string { return proto.CompactTextString(m) } func (*ConfChange) ProtoMessage() {} func (*ConfChange) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{6} } func (m *ConfChange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfChange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfChange) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfChange.Merge(dst, src) } func (m *ConfChange) XXX_Size() int { return m.Size() } func (m *ConfChange) XXX_DiscardUnknown() { xxx_messageInfo_ConfChange.DiscardUnknown(m) } var xxx_messageInfo_ConfChange proto.InternalMessageInfo func (m *ConfChange) GetChangeType() ConfChangeType { if m != nil { return m.ChangeType } return ConfChangeType_AddNode } func (m *ConfChange) GetNodeId() uint64 { if m != nil { return m.NodeId } return 0 } func (m *ConfChange) GetContext() []byte { if m != nil { return m.Context } return nil } func (m *ConfChange) GetId() uint64 { if m != nil { return m.Id } return 0 } // ConfChangeSingle is an individual configuration change operation. Multiple // such operations can be carried out atomically via a ConfChangeV2. type ConfChangeSingle struct { ChangeType ConfChangeType `protobuf:"varint,1,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` NodeId uint64 `protobuf:"varint,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfChangeSingle) Reset() { *m = ConfChangeSingle{} } func (m *ConfChangeSingle) String() string { return proto.CompactTextString(m) } func (*ConfChangeSingle) ProtoMessage() {} func (*ConfChangeSingle) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{7} } func (m *ConfChangeSingle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfChangeSingle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfChangeSingle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfChangeSingle) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfChangeSingle.Merge(dst, src) } func (m *ConfChangeSingle) XXX_Size() int { return m.Size() } func (m *ConfChangeSingle) XXX_DiscardUnknown() { xxx_messageInfo_ConfChangeSingle.DiscardUnknown(m) } var xxx_messageInfo_ConfChangeSingle proto.InternalMessageInfo func (m *ConfChangeSingle) GetChangeType() ConfChangeType { if m != nil { return m.ChangeType } return ConfChangeType_AddNode } func (m *ConfChangeSingle) GetNodeId() uint64 { if m != nil { return m.NodeId } return 0 } // ConfChangeV2 messages initiate configuration changes. They support both the // simple "one at a time" membership change protocol and full Joint Consensus // allowing for arbitrary changes in membership. // // The supplied context is treated as an opaque payload and can be used to // attach an action on the state machine to the application of the config change // proposal. Note that contrary to Joint Consensus as outlined in the Raft // paper[1], configuration changes become active when they are *applied* to the // state machine (not when they are appended to the log). // // The simple protocol can be used whenever only a single change is made. // // Non-simple changes require the use of Joint Consensus, for which two // configuration changes are run. The first configuration change specifies the // desired changes and transitions the Raft group into the joint configuration, // in which quorum requires a majority of both the pre-changes and post-changes // configuration. Joint Consensus avoids entering fragile intermediate // configurations that could compromise survivability. For example, without the // use of Joint Consensus and running across three availability zones with a // replication factor of three, it is not possible to replace a voter without // entering an intermediate configuration that does not survive the outage of // one availability zone. // // The provided ConfChangeTransition specifies how (and whether) Joint Consensus // is used, and assigns the task of leaving the joint configuration either to // Raft or the application. Leaving the joint configuration is accomplished by // proposing a ConfChangeV2 with only and optionally the Context field // populated. // // For details on Raft membership changes, see: // // [1]: https://github.com/ongardie/dissertation/blob/master/online-trim.pdf type ConfChangeV2 struct { Transition ConfChangeTransition `protobuf:"varint,1,opt,name=transition,proto3,enum=eraftpb.ConfChangeTransition" json:"transition,omitempty"` Changes []*ConfChangeSingle `protobuf:"bytes,2,rep,name=changes" json:"changes,omitempty"` Context []byte `protobuf:"bytes,3,opt,name=context,proto3" json:"context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ConfChangeV2) Reset() { *m = ConfChangeV2{} } func (m *ConfChangeV2) String() string { return proto.CompactTextString(m) } func (*ConfChangeV2) ProtoMessage() {} func (*ConfChangeV2) Descriptor() ([]byte, []int) { return fileDescriptor_eraftpb_0ace5493d3be806a, []int{8} } func (m *ConfChangeV2) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ConfChangeV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ConfChangeV2.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ConfChangeV2) XXX_Merge(src proto.Message) { xxx_messageInfo_ConfChangeV2.Merge(dst, src) } func (m *ConfChangeV2) XXX_Size() int { return m.Size() } func (m *ConfChangeV2) XXX_DiscardUnknown() { xxx_messageInfo_ConfChangeV2.DiscardUnknown(m) } var xxx_messageInfo_ConfChangeV2 proto.InternalMessageInfo func (m *ConfChangeV2) GetTransition() ConfChangeTransition { if m != nil { return m.Transition } return ConfChangeTransition_Auto } func (m *ConfChangeV2) GetChanges() []*ConfChangeSingle { if m != nil { return m.Changes } return nil } func (m *ConfChangeV2) GetContext() []byte { if m != nil { return m.Context } return nil } func init() { proto.RegisterType((*Entry)(nil), "eraftpb.Entry") proto.RegisterType((*SnapshotMetadata)(nil), "eraftpb.SnapshotMetadata") proto.RegisterType((*Snapshot)(nil), "eraftpb.Snapshot") proto.RegisterType((*Message)(nil), "eraftpb.Message") proto.RegisterType((*HardState)(nil), "eraftpb.HardState") proto.RegisterType((*ConfState)(nil), "eraftpb.ConfState") proto.RegisterType((*ConfChange)(nil), "eraftpb.ConfChange") proto.RegisterType((*ConfChangeSingle)(nil), "eraftpb.ConfChangeSingle") proto.RegisterType((*ConfChangeV2)(nil), "eraftpb.ConfChangeV2") proto.RegisterEnum("eraftpb.EntryType", EntryType_name, EntryType_value) proto.RegisterEnum("eraftpb.MessageType", MessageType_name, MessageType_value) proto.RegisterEnum("eraftpb.ConfChangeTransition", ConfChangeTransition_name, ConfChangeTransition_value) proto.RegisterEnum("eraftpb.ConfChangeType", ConfChangeType_name, ConfChangeType_value) } func (m *Entry) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Entry) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.EntryType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.EntryType)) } if m.Term != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Term)) } if m.Index != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Index)) } if len(m.Data) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.SyncLog { dAtA[i] = 0x28 i++ if m.SyncLog { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Context) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotMetadata) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotMetadata) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ConfState != nil { dAtA[i] = 0xa i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.ConfState.Size())) n1, err := m.ConfState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.Index != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Index)) } if m.Term != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Term)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Snapshot) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Data) > 0 { dAtA[i] = 0xa i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.Metadata != nil { dAtA[i] = 0x12 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Metadata.Size())) n2, err := m.Metadata.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Message) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Message) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.MsgType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.MsgType)) } if m.To != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.To)) } if m.From != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.From)) } if m.Term != 0 { dAtA[i] = 0x20 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Term)) } if m.LogTerm != 0 { dAtA[i] = 0x28 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.LogTerm)) } if m.Index != 0 { dAtA[i] = 0x30 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Index)) } if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0x3a i++ i = encodeVarintEraftpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Commit != 0 { dAtA[i] = 0x40 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Commit)) } if m.Snapshot != nil { dAtA[i] = 0x4a i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Snapshot.Size())) n3, err := m.Snapshot.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.Reject { dAtA[i] = 0x50 i++ if m.Reject { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.RejectHint != 0 { dAtA[i] = 0x58 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.RejectHint)) } if len(m.Context) > 0 { dAtA[i] = 0x62 i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.RequestSnapshot != 0 { dAtA[i] = 0x68 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.RequestSnapshot)) } if m.Priority != 0 { dAtA[i] = 0x70 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Priority)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *HardState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *HardState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Term != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Term)) } if m.Vote != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Vote)) } if m.Commit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Commit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Voters) > 0 { dAtA5 := make([]byte, len(m.Voters)*10) var j4 int for _, num := range m.Voters { for num >= 1<<7 { dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j4++ } dAtA5[j4] = uint8(num) j4++ } dAtA[i] = 0xa i++ i = encodeVarintEraftpb(dAtA, i, uint64(j4)) i += copy(dAtA[i:], dAtA5[:j4]) } if len(m.Learners) > 0 { dAtA7 := make([]byte, len(m.Learners)*10) var j6 int for _, num := range m.Learners { for num >= 1<<7 { dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j6++ } dAtA7[j6] = uint8(num) j6++ } dAtA[i] = 0x12 i++ i = encodeVarintEraftpb(dAtA, i, uint64(j6)) i += copy(dAtA[i:], dAtA7[:j6]) } if len(m.VotersOutgoing) > 0 { dAtA9 := make([]byte, len(m.VotersOutgoing)*10) var j8 int for _, num := range m.VotersOutgoing { for num >= 1<<7 { dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j8++ } dAtA9[j8] = uint8(num) j8++ } dAtA[i] = 0x1a i++ i = encodeVarintEraftpb(dAtA, i, uint64(j8)) i += copy(dAtA[i:], dAtA9[:j8]) } if len(m.LearnersNext) > 0 { dAtA11 := make([]byte, len(m.LearnersNext)*10) var j10 int for _, num := range m.LearnersNext { for num >= 1<<7 { dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j10++ } dAtA11[j10] = uint8(num) j10++ } dAtA[i] = 0x22 i++ i = encodeVarintEraftpb(dAtA, i, uint64(j10)) i += copy(dAtA[i:], dAtA11[:j10]) } if m.AutoLeave { dAtA[i] = 0x28 i++ if m.AutoLeave { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfChange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfChange) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Id)) } if m.ChangeType != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.ChangeType)) } if m.NodeId != 0 { dAtA[i] = 0x18 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.NodeId)) } if len(m.Context) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfChangeSingle) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfChangeSingle) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ChangeType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.ChangeType)) } if m.NodeId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.NodeId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ConfChangeV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ConfChangeV2) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Transition != 0 { dAtA[i] = 0x8 i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Transition)) } if len(m.Changes) > 0 { for _, msg := range m.Changes { dAtA[i] = 0x12 i++ i = encodeVarintEraftpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Context) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintEraftpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *Entry) Size() (n int) { var l int _ = l if m.EntryType != 0 { n += 1 + sovEraftpb(uint64(m.EntryType)) } if m.Term != 0 { n += 1 + sovEraftpb(uint64(m.Term)) } if m.Index != 0 { n += 1 + sovEraftpb(uint64(m.Index)) } l = len(m.Data) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.SyncLog { n += 2 } l = len(m.Context) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotMetadata) Size() (n int) { var l int _ = l if m.ConfState != nil { l = m.ConfState.Size() n += 1 + l + sovEraftpb(uint64(l)) } if m.Index != 0 { n += 1 + sovEraftpb(uint64(m.Index)) } if m.Term != 0 { n += 1 + sovEraftpb(uint64(m.Term)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Snapshot) Size() (n int) { var l int _ = l l = len(m.Data) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovEraftpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Message) Size() (n int) { var l int _ = l if m.MsgType != 0 { n += 1 + sovEraftpb(uint64(m.MsgType)) } if m.To != 0 { n += 1 + sovEraftpb(uint64(m.To)) } if m.From != 0 { n += 1 + sovEraftpb(uint64(m.From)) } if m.Term != 0 { n += 1 + sovEraftpb(uint64(m.Term)) } if m.LogTerm != 0 { n += 1 + sovEraftpb(uint64(m.LogTerm)) } if m.Index != 0 { n += 1 + sovEraftpb(uint64(m.Index)) } if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovEraftpb(uint64(l)) } } if m.Commit != 0 { n += 1 + sovEraftpb(uint64(m.Commit)) } if m.Snapshot != nil { l = m.Snapshot.Size() n += 1 + l + sovEraftpb(uint64(l)) } if m.Reject { n += 2 } if m.RejectHint != 0 { n += 1 + sovEraftpb(uint64(m.RejectHint)) } l = len(m.Context) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.RequestSnapshot != 0 { n += 1 + sovEraftpb(uint64(m.RequestSnapshot)) } if m.Priority != 0 { n += 1 + sovEraftpb(uint64(m.Priority)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *HardState) Size() (n int) { var l int _ = l if m.Term != 0 { n += 1 + sovEraftpb(uint64(m.Term)) } if m.Vote != 0 { n += 1 + sovEraftpb(uint64(m.Vote)) } if m.Commit != 0 { n += 1 + sovEraftpb(uint64(m.Commit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfState) Size() (n int) { var l int _ = l if len(m.Voters) > 0 { l = 0 for _, e := range m.Voters { l += sovEraftpb(uint64(e)) } n += 1 + sovEraftpb(uint64(l)) + l } if len(m.Learners) > 0 { l = 0 for _, e := range m.Learners { l += sovEraftpb(uint64(e)) } n += 1 + sovEraftpb(uint64(l)) + l } if len(m.VotersOutgoing) > 0 { l = 0 for _, e := range m.VotersOutgoing { l += sovEraftpb(uint64(e)) } n += 1 + sovEraftpb(uint64(l)) + l } if len(m.LearnersNext) > 0 { l = 0 for _, e := range m.LearnersNext { l += sovEraftpb(uint64(e)) } n += 1 + sovEraftpb(uint64(l)) + l } if m.AutoLeave { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfChange) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovEraftpb(uint64(m.Id)) } if m.ChangeType != 0 { n += 1 + sovEraftpb(uint64(m.ChangeType)) } if m.NodeId != 0 { n += 1 + sovEraftpb(uint64(m.NodeId)) } l = len(m.Context) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfChangeSingle) Size() (n int) { var l int _ = l if m.ChangeType != 0 { n += 1 + sovEraftpb(uint64(m.ChangeType)) } if m.NodeId != 0 { n += 1 + sovEraftpb(uint64(m.NodeId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ConfChangeV2) Size() (n int) { var l int _ = l if m.Transition != 0 { n += 1 + sovEraftpb(uint64(m.Transition)) } if len(m.Changes) > 0 { for _, e := range m.Changes { l = e.Size() n += 1 + l + sovEraftpb(uint64(l)) } } l = len(m.Context) if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovEraftpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozEraftpb(x uint64) (n int) { return sovEraftpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *Entry) 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 ErrIntOverflowEraftpb } 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: Entry: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EntryType", wireType) } m.EntryType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EntryType |= (EntryType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: 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 ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen 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 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SyncLog = bool(v != 0) case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *SnapshotMetadata) 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 ErrIntOverflowEraftpb } 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: SnapshotMetadata: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotMetadata: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConfState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ConfState == nil { m.ConfState = &ConfState{} } if err := m.ConfState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *Snapshot) 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 ErrIntOverflowEraftpb } 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: Snapshot: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen 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 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Metadata == nil { m.Metadata = &SnapshotMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *Message) 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 ErrIntOverflowEraftpb } 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: Message: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MsgType", wireType) } m.MsgType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MsgType |= (MessageType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) } m.To = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.To |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) } m.From = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.From |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LogTerm", wireType) } m.LogTerm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LogTerm |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &Entry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Snapshot == nil { m.Snapshot = &Snapshot{} } if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Reject", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Reject = bool(v != 0) case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RejectHint", wireType) } m.RejectHint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RejectHint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RequestSnapshot", wireType) } m.RequestSnapshot = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RequestSnapshot |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType) } m.Priority = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Priority |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *HardState) 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 ErrIntOverflowEraftpb } 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: HardState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: HardState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) } m.Vote = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Vote |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *ConfState) 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 ErrIntOverflowEraftpb } 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: ConfState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Voters = append(m.Voters, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Voters = append(m.Voters, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Voters", wireType) } case 2: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Learners = append(m.Learners, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Learners = append(m.Learners, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType) } case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.VotersOutgoing = append(m.VotersOutgoing, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.VotersOutgoing = append(m.VotersOutgoing, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field VotersOutgoing", wireType) } case 4: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.LearnersNext = append(m.LearnersNext, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.LearnersNext = append(m.LearnersNext, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field LearnersNext", wireType) } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AutoLeave", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.AutoLeave = bool(v != 0) default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *ConfChange) 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 ErrIntOverflowEraftpb } 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: ConfChange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfChange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) } m.ChangeType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ChangeType |= (ConfChangeType(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType) } m.NodeId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NodeId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *ConfChangeSingle) 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 ErrIntOverflowEraftpb } 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: ConfChangeSingle: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfChangeSingle: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) } m.ChangeType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ChangeType |= (ConfChangeType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType) } m.NodeId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NodeId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 *ConfChangeV2) 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 ErrIntOverflowEraftpb } 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: ConfChangeV2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ConfChangeV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Transition", wireType) } m.Transition = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Transition |= (ConfChangeTransition(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Changes = append(m.Changes, &ConfChangeSingle{}) if err := m.Changes[len(m.Changes)-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 Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEraftpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthEraftpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEraftpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthEraftpb } 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 skipEraftpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEraftpb } 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, ErrIntOverflowEraftpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEraftpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthEraftpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowEraftpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipEraftpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthEraftpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowEraftpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("eraftpb.proto", fileDescriptor_eraftpb_0ace5493d3be806a) } var fileDescriptor_eraftpb_0ace5493d3be806a = []byte{ // 1012 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x6e, 0xe4, 0x44, 0x10, 0x8e, 0x3d, 0x93, 0xb1, 0xa7, 0xe6, 0x27, 0x9d, 0x26, 0xec, 0x3a, 0x2b, 0x25, 0x8c, 0x86, 0x03, 0x43, 0x24, 0x16, 0x6d, 0x56, 0x48, 0x1c, 0xe0, 0x90, 0x8d, 0x56, 0x4a, 0x44, 0x26, 0x2c, 0x4e, 0x36, 0x57, 0xcb, 0xb1, 0x2b, 0x8e, 0x61, 0xdc, 0x6d, 0xba, 0x7b, 0x42, 0xf2, 0x08, 0x48, 0x3c, 0x00, 0x07, 0x1e, 0x01, 0x78, 0x0e, 0x8e, 0x3c, 0x02, 0x0a, 0x2f, 0x82, 0xba, 0xdd, 0x76, 0x3c, 0xd9, 0x3d, 0x71, 0xab, 0xfa, 0x5c, 0x55, 0xfd, 0xd5, 0x57, 0xd5, 0x2d, 0xc3, 0x08, 0x45, 0x7c, 0xa5, 0xca, 0xcb, 0xe7, 0xa5, 0xe0, 0x8a, 0x53, 0xcf, 0xba, 0xd3, 0x3f, 0x1c, 0x58, 0x7f, 0xcd, 0x94, 0xb8, 0xa3, 0x2f, 0x00, 0x50, 0x1b, 0x91, 0xba, 0x2b, 0x31, 0x70, 0x26, 0xce, 0x6c, 0xbc, 0x4f, 0x9f, 0xd7, 0x69, 0x26, 0xe6, 0xfc, 0xae, 0xc4, 0xb0, 0x8f, 0xb5, 0x49, 0x29, 0x74, 0x15, 0x8a, 0x22, 0x70, 0x27, 0xce, 0xac, 0x1b, 0x1a, 0x9b, 0x6e, 0xc1, 0x7a, 0xce, 0x52, 0xbc, 0x0d, 0x3a, 0x06, 0xac, 0x1c, 0x1d, 0x99, 0xc6, 0x2a, 0x0e, 0xba, 0x13, 0x67, 0x36, 0x0c, 0x8d, 0x4d, 0xb7, 0xc1, 0x97, 0x77, 0x2c, 0x89, 0x16, 0x3c, 0x0b, 0xd6, 0x27, 0xce, 0xcc, 0x0f, 0x3d, 0xed, 0x9f, 0xf0, 0x8c, 0x06, 0xe0, 0x25, 0x9c, 0x29, 0xbc, 0x55, 0x41, 0xcf, 0x64, 0xd4, 0xee, 0x94, 0x03, 0x39, 0x63, 0x71, 0x29, 0xaf, 0xb9, 0x9a, 0xa3, 0x8a, 0x4d, 0xa1, 0x17, 0x00, 0x09, 0x67, 0x57, 0x91, 0x54, 0xb1, 0xaa, 0x98, 0x0f, 0x5a, 0xcc, 0x0f, 0x39, 0xbb, 0x3a, 0xd3, 0x5f, 0xc2, 0x7e, 0x52, 0x9b, 0x0f, 0x2c, 0xdd, 0x47, 0x2c, 0x4d, 0x3f, 0x9d, 0x87, 0x7e, 0xa6, 0x6f, 0xc1, 0xaf, 0x0f, 0x6c, 0xba, 0x70, 0x5a, 0x5d, 0x7c, 0x01, 0x7e, 0x61, 0x89, 0x98, 0x62, 0x83, 0xfd, 0xed, 0xe6, 0xe8, 0xc7, 0x4c, 0xc3, 0x26, 0x74, 0xfa, 0x67, 0x07, 0xbc, 0x39, 0x4a, 0x19, 0x67, 0x48, 0x3f, 0x07, 0xbf, 0x90, 0x59, 0x5b, 0xf7, 0xad, 0xa6, 0x84, 0x8d, 0x31, 0xca, 0x7b, 0x85, 0xcc, 0x8c, 0xee, 0x63, 0x70, 0x15, 0xb7, 0xd4, 0x5d, 0xc5, 0x35, 0xaf, 0x2b, 0xc1, 0x1b, 0xde, 0xda, 0x6e, 0x7a, 0xe9, 0xb6, 0x66, 0xb3, 0x0d, 0xfe, 0x82, 0x67, 0x91, 0xc1, 0xd7, 0x0d, 0xee, 0x2d, 0x78, 0x76, 0xbe, 0x32, 0xb6, 0x5e, 0x5b, 0x90, 0x19, 0x78, 0x7a, 0xda, 0x39, 0xca, 0xc0, 0x9b, 0x74, 0x66, 0x83, 0xfd, 0xf1, 0xea, 0x42, 0x84, 0xf5, 0x67, 0xfa, 0x04, 0x7a, 0x09, 0x2f, 0x8a, 0x5c, 0x05, 0xbe, 0x29, 0x60, 0x3d, 0xfa, 0x19, 0xf8, 0xd2, 0xaa, 0x10, 0xf4, 0x8d, 0x3c, 0x9b, 0xef, 0xc8, 0x13, 0x36, 0x21, 0xba, 0x8c, 0xc0, 0xef, 0x31, 0x51, 0x01, 0x98, 0x8d, 0xb0, 0x1e, 0xfd, 0x08, 0x06, 0x95, 0x15, 0x5d, 0xe7, 0x4c, 0x05, 0x03, 0x73, 0x06, 0x54, 0xd0, 0x51, 0xce, 0x54, 0x7b, 0x63, 0x86, 0x2b, 0x1b, 0x43, 0x3f, 0x05, 0x22, 0xf0, 0xc7, 0x25, 0x4a, 0x15, 0x35, 0x4c, 0x46, 0x26, 0x7f, 0xc3, 0xe2, 0xcd, 0x7c, 0x9f, 0x81, 0x5f, 0x8a, 0x9c, 0x8b, 0x5c, 0xdd, 0x05, 0x63, 0x13, 0xd2, 0xf8, 0xd3, 0x6f, 0xa0, 0x7f, 0x14, 0x8b, 0xb4, 0x5a, 0x9f, 0x5a, 0x5c, 0xa7, 0x25, 0x2e, 0x85, 0xee, 0x0d, 0x57, 0x58, 0x5f, 0x06, 0x6d, 0xb7, 0x54, 0xe9, 0xb4, 0x55, 0x99, 0xfe, 0xee, 0x40, 0xbf, 0xd9, 0x4b, 0x1d, 0xa5, 0xa3, 0x85, 0x0c, 0x9c, 0x49, 0x47, 0x47, 0x55, 0x9e, 0xa6, 0xb3, 0xc0, 0x58, 0x30, 0xfd, 0xc5, 0x35, 0x5f, 0x1a, 0x9f, 0x7e, 0x02, 0x1b, 0x55, 0x54, 0xc4, 0x97, 0x2a, 0xe3, 0x39, 0xcb, 0x82, 0x8e, 0x09, 0x19, 0x57, 0xf0, 0xb7, 0x16, 0xa5, 0x1f, 0xc3, 0xa8, 0x4e, 0x8a, 0x98, 0x96, 0xa7, 0x6b, 0xc2, 0x86, 0x35, 0x78, 0xaa, 0x35, 0xda, 0x01, 0x88, 0x97, 0x8a, 0x47, 0x0b, 0x8c, 0x6f, 0xd0, 0x5e, 0xc6, 0xbe, 0x46, 0x4e, 0x34, 0x30, 0xfd, 0xd9, 0x01, 0xd0, 0x74, 0x0f, 0xaf, 0x63, 0x96, 0x99, 0xf5, 0xcb, 0x53, 0xdb, 0xbb, 0x9b, 0xa7, 0xf4, 0x4b, 0x18, 0x24, 0xe6, 0x4b, 0xb5, 0xc2, 0xae, 0x59, 0xe1, 0xa7, 0x2b, 0x17, 0xb0, 0xca, 0x34, 0x5b, 0x0c, 0x49, 0x63, 0xd3, 0xa7, 0xe0, 0x31, 0x9e, 0x62, 0x94, 0xa7, 0xb5, 0x40, 0xda, 0x3d, 0x4e, 0xdb, 0xe3, 0xec, 0xae, 0x3e, 0x00, 0x08, 0xe4, 0xa1, 0xe0, 0x59, 0xce, 0xb2, 0x05, 0x3e, 0x26, 0xe0, 0xfc, 0x2f, 0x02, 0x6e, 0x9b, 0xc0, 0xf4, 0x37, 0x07, 0x86, 0x0f, 0x79, 0x17, 0xfb, 0xf4, 0x6b, 0x00, 0x25, 0x62, 0x26, 0x73, 0x95, 0x73, 0x66, 0x8f, 0xd8, 0x79, 0xdf, 0x11, 0x4d, 0x50, 0xd8, 0x4a, 0xa0, 0x2f, 0xc1, 0xab, 0x8e, 0xad, 0x46, 0xd9, 0x7e, 0x25, 0x1e, 0xb7, 0x13, 0xd6, 0x91, 0x6d, 0x15, 0x3a, 0x2b, 0x2a, 0xec, 0x1d, 0x41, 0xbf, 0x79, 0x91, 0xe9, 0x06, 0x0c, 0x8c, 0x73, 0xca, 0x45, 0x11, 0x2f, 0xc8, 0x1a, 0xfd, 0x00, 0x36, 0x0c, 0xf0, 0x50, 0x99, 0x38, 0xf4, 0x43, 0xd8, 0x7c, 0x04, 0x5e, 0xec, 0x13, 0x77, 0xef, 0x97, 0x0e, 0x0c, 0x5a, 0x8f, 0x0c, 0x05, 0xe8, 0xcd, 0x65, 0x76, 0xb4, 0x2c, 0xc9, 0x1a, 0x1d, 0x80, 0x37, 0x97, 0xd9, 0x2b, 0x8c, 0x15, 0x71, 0xe8, 0x18, 0x60, 0x2e, 0xb3, 0x37, 0x82, 0x97, 0x5c, 0x22, 0x71, 0xe9, 0x08, 0xfa, 0x73, 0x99, 0x1d, 0x94, 0x25, 0xb2, 0x94, 0x74, 0x74, 0xf9, 0xc6, 0x0d, 0x51, 0x96, 0x9c, 0x49, 0x24, 0x5d, 0x4a, 0x61, 0x3c, 0x97, 0x59, 0x58, 0x5d, 0xb4, 0x0b, 0xae, 0x90, 0xac, 0xd3, 0x67, 0xf0, 0x64, 0x15, 0x6b, 0xe2, 0x7b, 0xba, 0x97, 0xb9, 0xcc, 0xea, 0x1b, 0x49, 0x3c, 0x4a, 0x60, 0xa8, 0xf9, 0x60, 0x2c, 0xd4, 0xa5, 0x26, 0xe2, 0xd3, 0x00, 0xb6, 0xda, 0x48, 0x93, 0xdc, 0xb7, 0x87, 0xbd, 0x65, 0x02, 0xe3, 0xe4, 0x3a, 0xbe, 0x5c, 0x20, 0x01, 0xba, 0x09, 0x23, 0x5b, 0x50, 0x5f, 0xb6, 0xa5, 0x24, 0x03, 0x1b, 0x76, 0x78, 0x8d, 0xc9, 0x0f, 0xdf, 0x2d, 0xb9, 0x58, 0x16, 0x64, 0x68, 0xe9, 0x9b, 0xe1, 0x5d, 0xa1, 0x38, 0xc1, 0x38, 0x45, 0x41, 0x46, 0x36, 0xfb, 0x3c, 0x2f, 0x90, 0x2f, 0xd5, 0x29, 0xff, 0x89, 0x8c, 0x2d, 0xa1, 0x10, 0xe3, 0xf4, 0x58, 0xbf, 0x91, 0x64, 0x83, 0x6e, 0x01, 0x69, 0x23, 0x9a, 0x10, 0x21, 0xb6, 0xa2, 0xed, 0xf2, 0x8d, 0x40, 0xd3, 0xfc, 0x26, 0xdd, 0x81, 0xed, 0x77, 0xe0, 0xa6, 0x05, 0xba, 0xf7, 0x15, 0x6c, 0xbd, 0x6f, 0x97, 0xa8, 0x0f, 0xdd, 0x83, 0xa5, 0xe2, 0x64, 0x8d, 0x0e, 0xc1, 0x3f, 0x2e, 0xca, 0x45, 0x9e, 0xe4, 0x7a, 0x2a, 0x43, 0xf0, 0x5f, 0xdf, 0x5a, 0xcf, 0xdd, 0x3b, 0x80, 0xf1, 0xea, 0xb2, 0xeb, 0x11, 0x1e, 0xa4, 0xe9, 0x29, 0x4f, 0x91, 0xac, 0xe9, 0x11, 0x86, 0x58, 0xf0, 0x1b, 0x34, 0xbe, 0xa3, 0x85, 0x38, 0x48, 0xd3, 0x93, 0xea, 0x25, 0x30, 0x98, 0xfb, 0x8a, 0xfc, 0x75, 0xbf, 0xeb, 0xfc, 0x7d, 0xbf, 0xeb, 0xfc, 0x73, 0xbf, 0xeb, 0xfc, 0xfa, 0xef, 0xee, 0xda, 0x65, 0xcf, 0xfc, 0x32, 0xbc, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x01, 0x2b, 0x4b, 0x47, 0x43, 0x08, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/errorpb/000077500000000000000000000000001421456440000165415ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/errorpb/errorpb.pb.go000066400000000000000000003114031421456440000211450ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: errorpb.proto package errorpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" metapb "github.com/pingcap/kvproto/pkg/metapb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // NotLeader is the error variant that tells a request be handle by raft leader // is sent to raft follower or learner. type NotLeader struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // Region leader of the requested region Leader *metapb.Peer `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NotLeader) Reset() { *m = NotLeader{} } func (m *NotLeader) String() string { return proto.CompactTextString(m) } func (*NotLeader) ProtoMessage() {} func (*NotLeader) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{0} } func (m *NotLeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NotLeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NotLeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *NotLeader) XXX_Merge(src proto.Message) { xxx_messageInfo_NotLeader.Merge(dst, src) } func (m *NotLeader) XXX_Size() int { return m.Size() } func (m *NotLeader) XXX_DiscardUnknown() { xxx_messageInfo_NotLeader.DiscardUnknown(m) } var xxx_messageInfo_NotLeader proto.InternalMessageInfo func (m *NotLeader) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *NotLeader) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } type DiskFull struct { // The requested store ID StoreId []uint64 `protobuf:"varint,1,rep,packed,name=store_id,json=storeId" json:"store_id,omitempty"` // The detailed info Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DiskFull) Reset() { *m = DiskFull{} } func (m *DiskFull) String() string { return proto.CompactTextString(m) } func (*DiskFull) ProtoMessage() {} func (*DiskFull) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{1} } func (m *DiskFull) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DiskFull) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DiskFull.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DiskFull) XXX_Merge(src proto.Message) { xxx_messageInfo_DiskFull.Merge(dst, src) } func (m *DiskFull) XXX_Size() int { return m.Size() } func (m *DiskFull) XXX_DiscardUnknown() { xxx_messageInfo_DiskFull.DiscardUnknown(m) } var xxx_messageInfo_DiskFull proto.InternalMessageInfo func (m *DiskFull) GetStoreId() []uint64 { if m != nil { return m.StoreId } return nil } func (m *DiskFull) GetReason() string { if m != nil { return m.Reason } return "" } // StoreNotMatch is the error variant that tells the request is sent to wrong store. // (i.e. inconsistency of the store ID that request shows and the real store ID of this server.) type StoreNotMatch struct { // Store id in request RequestStoreId uint64 `protobuf:"varint,1,opt,name=request_store_id,json=requestStoreId,proto3" json:"request_store_id,omitempty"` // Actual store id ActualStoreId uint64 `protobuf:"varint,2,opt,name=actual_store_id,json=actualStoreId,proto3" json:"actual_store_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreNotMatch) Reset() { *m = StoreNotMatch{} } func (m *StoreNotMatch) String() string { return proto.CompactTextString(m) } func (*StoreNotMatch) ProtoMessage() {} func (*StoreNotMatch) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{2} } func (m *StoreNotMatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreNotMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreNotMatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreNotMatch) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreNotMatch.Merge(dst, src) } func (m *StoreNotMatch) XXX_Size() int { return m.Size() } func (m *StoreNotMatch) XXX_DiscardUnknown() { xxx_messageInfo_StoreNotMatch.DiscardUnknown(m) } var xxx_messageInfo_StoreNotMatch proto.InternalMessageInfo func (m *StoreNotMatch) GetRequestStoreId() uint64 { if m != nil { return m.RequestStoreId } return 0 } func (m *StoreNotMatch) GetActualStoreId() uint64 { if m != nil { return m.ActualStoreId } return 0 } // RegionNotFound is the error variant that tells there isn't any region in this TiKV // matches the requested region ID. type RegionNotFound struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionNotFound) Reset() { *m = RegionNotFound{} } func (m *RegionNotFound) String() string { return proto.CompactTextString(m) } func (*RegionNotFound) ProtoMessage() {} func (*RegionNotFound) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{3} } func (m *RegionNotFound) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionNotFound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionNotFound.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionNotFound) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionNotFound.Merge(dst, src) } func (m *RegionNotFound) XXX_Size() int { return m.Size() } func (m *RegionNotFound) XXX_DiscardUnknown() { xxx_messageInfo_RegionNotFound.DiscardUnknown(m) } var xxx_messageInfo_RegionNotFound proto.InternalMessageInfo func (m *RegionNotFound) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } // RegionNotInitialized is the error variant that tells there isn't any initialized peer // matchesthe request region ID. type RegionNotInitialized struct { // The request region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionNotInitialized) Reset() { *m = RegionNotInitialized{} } func (m *RegionNotInitialized) String() string { return proto.CompactTextString(m) } func (*RegionNotInitialized) ProtoMessage() {} func (*RegionNotInitialized) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{4} } func (m *RegionNotInitialized) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionNotInitialized) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionNotInitialized.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionNotInitialized) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionNotInitialized.Merge(dst, src) } func (m *RegionNotInitialized) XXX_Size() int { return m.Size() } func (m *RegionNotInitialized) XXX_DiscardUnknown() { xxx_messageInfo_RegionNotInitialized.DiscardUnknown(m) } var xxx_messageInfo_RegionNotInitialized proto.InternalMessageInfo func (m *RegionNotInitialized) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } // KeyNotInRegion is the error variant that tells the key the request requires isn't present in // this region. type KeyNotInRegion struct { // The requested key Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The requested region ID RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // Start key of the requested region StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` // Snd key of the requested region EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyNotInRegion) Reset() { *m = KeyNotInRegion{} } func (m *KeyNotInRegion) String() string { return proto.CompactTextString(m) } func (*KeyNotInRegion) ProtoMessage() {} func (*KeyNotInRegion) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{5} } func (m *KeyNotInRegion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyNotInRegion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyNotInRegion.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyNotInRegion) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyNotInRegion.Merge(dst, src) } func (m *KeyNotInRegion) XXX_Size() int { return m.Size() } func (m *KeyNotInRegion) XXX_DiscardUnknown() { xxx_messageInfo_KeyNotInRegion.DiscardUnknown(m) } var xxx_messageInfo_KeyNotInRegion proto.InternalMessageInfo func (m *KeyNotInRegion) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *KeyNotInRegion) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *KeyNotInRegion) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *KeyNotInRegion) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } // EpochNotMatch is the error variant that tells a region has been updated. // (e.g. by splitting / merging, or raft Confchange.) // Hence, a command is based on a stale version of a region. type EpochNotMatch struct { // Available regions that may be siblings of the requested one. CurrentRegions []*metapb.Region `protobuf:"bytes,1,rep,name=current_regions,json=currentRegions" json:"current_regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *EpochNotMatch) Reset() { *m = EpochNotMatch{} } func (m *EpochNotMatch) String() string { return proto.CompactTextString(m) } func (*EpochNotMatch) ProtoMessage() {} func (*EpochNotMatch) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{6} } func (m *EpochNotMatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *EpochNotMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EpochNotMatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *EpochNotMatch) XXX_Merge(src proto.Message) { xxx_messageInfo_EpochNotMatch.Merge(dst, src) } func (m *EpochNotMatch) XXX_Size() int { return m.Size() } func (m *EpochNotMatch) XXX_DiscardUnknown() { xxx_messageInfo_EpochNotMatch.DiscardUnknown(m) } var xxx_messageInfo_EpochNotMatch proto.InternalMessageInfo func (m *EpochNotMatch) GetCurrentRegions() []*metapb.Region { if m != nil { return m.CurrentRegions } return nil } // ServerIsBusy is the error variant that tells the server is too busy to response. type ServerIsBusy struct { Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` // The suggested backoff time BackoffMs uint64 `protobuf:"varint,2,opt,name=backoff_ms,json=backoffMs,proto3" json:"backoff_ms,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ServerIsBusy) Reset() { *m = ServerIsBusy{} } func (m *ServerIsBusy) String() string { return proto.CompactTextString(m) } func (*ServerIsBusy) ProtoMessage() {} func (*ServerIsBusy) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{7} } func (m *ServerIsBusy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ServerIsBusy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ServerIsBusy.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ServerIsBusy) XXX_Merge(src proto.Message) { xxx_messageInfo_ServerIsBusy.Merge(dst, src) } func (m *ServerIsBusy) XXX_Size() int { return m.Size() } func (m *ServerIsBusy) XXX_DiscardUnknown() { xxx_messageInfo_ServerIsBusy.DiscardUnknown(m) } var xxx_messageInfo_ServerIsBusy proto.InternalMessageInfo func (m *ServerIsBusy) GetReason() string { if m != nil { return m.Reason } return "" } func (m *ServerIsBusy) GetBackoffMs() uint64 { if m != nil { return m.BackoffMs } return 0 } // StaleCommand is the error variant that tells the command is stale, that is, // the current request term is lower than current raft term. // This can be retried at most time. type StaleCommand struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StaleCommand) Reset() { *m = StaleCommand{} } func (m *StaleCommand) String() string { return proto.CompactTextString(m) } func (*StaleCommand) ProtoMessage() {} func (*StaleCommand) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{8} } func (m *StaleCommand) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StaleCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StaleCommand.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StaleCommand) XXX_Merge(src proto.Message) { xxx_messageInfo_StaleCommand.Merge(dst, src) } func (m *StaleCommand) XXX_Size() int { return m.Size() } func (m *StaleCommand) XXX_DiscardUnknown() { xxx_messageInfo_StaleCommand.DiscardUnknown(m) } var xxx_messageInfo_StaleCommand proto.InternalMessageInfo // RaftEntryTooLarge is the error variant that tells the request is too large to be serialized to a // reasonable small raft entry. // (i.e. greater than the configured value `raft_entry_max_size` in `raftstore`) type RaftEntryTooLarge struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // Size of the raft entry EntrySize uint64 `protobuf:"varint,2,opt,name=entry_size,json=entrySize,proto3" json:"entry_size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftEntryTooLarge) Reset() { *m = RaftEntryTooLarge{} } func (m *RaftEntryTooLarge) String() string { return proto.CompactTextString(m) } func (*RaftEntryTooLarge) ProtoMessage() {} func (*RaftEntryTooLarge) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{9} } func (m *RaftEntryTooLarge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftEntryTooLarge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftEntryTooLarge.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftEntryTooLarge) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftEntryTooLarge.Merge(dst, src) } func (m *RaftEntryTooLarge) XXX_Size() int { return m.Size() } func (m *RaftEntryTooLarge) XXX_DiscardUnknown() { xxx_messageInfo_RaftEntryTooLarge.DiscardUnknown(m) } var xxx_messageInfo_RaftEntryTooLarge proto.InternalMessageInfo func (m *RaftEntryTooLarge) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RaftEntryTooLarge) GetEntrySize() uint64 { if m != nil { return m.EntrySize } return 0 } // MaxTimestampNotSynced is the error variant that tells the peer has just become a leader and // updating the max timestamp in the concurrency manager from PD TSO is ongoing. In this case, // the prewrite of an async commit transaction cannot succeed. The client can backoff and // resend the request. type MaxTimestampNotSynced struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MaxTimestampNotSynced) Reset() { *m = MaxTimestampNotSynced{} } func (m *MaxTimestampNotSynced) String() string { return proto.CompactTextString(m) } func (*MaxTimestampNotSynced) ProtoMessage() {} func (*MaxTimestampNotSynced) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{10} } func (m *MaxTimestampNotSynced) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MaxTimestampNotSynced) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MaxTimestampNotSynced.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MaxTimestampNotSynced) XXX_Merge(src proto.Message) { xxx_messageInfo_MaxTimestampNotSynced.Merge(dst, src) } func (m *MaxTimestampNotSynced) XXX_Size() int { return m.Size() } func (m *MaxTimestampNotSynced) XXX_DiscardUnknown() { xxx_messageInfo_MaxTimestampNotSynced.DiscardUnknown(m) } var xxx_messageInfo_MaxTimestampNotSynced proto.InternalMessageInfo // ReadIndexNotReady is the error variant that tells the read index request is not ready, that is, // the current region is in a status that not ready to serve the read index request. For example, // region is in splitting or merging status. // This can be retried at most time. type ReadIndexNotReady struct { // The reason why the region is not ready to serve read index request Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` // The requested region ID RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadIndexNotReady) Reset() { *m = ReadIndexNotReady{} } func (m *ReadIndexNotReady) String() string { return proto.CompactTextString(m) } func (*ReadIndexNotReady) ProtoMessage() {} func (*ReadIndexNotReady) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{11} } func (m *ReadIndexNotReady) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadIndexNotReady) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadIndexNotReady.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadIndexNotReady) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadIndexNotReady.Merge(dst, src) } func (m *ReadIndexNotReady) XXX_Size() int { return m.Size() } func (m *ReadIndexNotReady) XXX_DiscardUnknown() { xxx_messageInfo_ReadIndexNotReady.DiscardUnknown(m) } var xxx_messageInfo_ReadIndexNotReady proto.InternalMessageInfo func (m *ReadIndexNotReady) GetReason() string { if m != nil { return m.Reason } return "" } func (m *ReadIndexNotReady) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } // ProposalInMergingMode is the error variant that tells the proposal is rejected because raft is // in the merging mode. This may happen when BR/Lightning try to ingest SST. // This can be retried at most time. type ProposalInMergingMode struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ProposalInMergingMode) Reset() { *m = ProposalInMergingMode{} } func (m *ProposalInMergingMode) String() string { return proto.CompactTextString(m) } func (*ProposalInMergingMode) ProtoMessage() {} func (*ProposalInMergingMode) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{12} } func (m *ProposalInMergingMode) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ProposalInMergingMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ProposalInMergingMode.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ProposalInMergingMode) XXX_Merge(src proto.Message) { xxx_messageInfo_ProposalInMergingMode.Merge(dst, src) } func (m *ProposalInMergingMode) XXX_Size() int { return m.Size() } func (m *ProposalInMergingMode) XXX_DiscardUnknown() { xxx_messageInfo_ProposalInMergingMode.DiscardUnknown(m) } var xxx_messageInfo_ProposalInMergingMode proto.InternalMessageInfo func (m *ProposalInMergingMode) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type DataIsNotReady struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` PeerId uint64 `protobuf:"varint,2,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"` SafeTs uint64 `protobuf:"varint,3,opt,name=safe_ts,json=safeTs,proto3" json:"safe_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DataIsNotReady) Reset() { *m = DataIsNotReady{} } func (m *DataIsNotReady) String() string { return proto.CompactTextString(m) } func (*DataIsNotReady) ProtoMessage() {} func (*DataIsNotReady) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{13} } func (m *DataIsNotReady) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DataIsNotReady) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DataIsNotReady.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DataIsNotReady) XXX_Merge(src proto.Message) { xxx_messageInfo_DataIsNotReady.Merge(dst, src) } func (m *DataIsNotReady) XXX_Size() int { return m.Size() } func (m *DataIsNotReady) XXX_DiscardUnknown() { xxx_messageInfo_DataIsNotReady.DiscardUnknown(m) } var xxx_messageInfo_DataIsNotReady proto.InternalMessageInfo func (m *DataIsNotReady) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *DataIsNotReady) GetPeerId() uint64 { if m != nil { return m.PeerId } return 0 } func (m *DataIsNotReady) GetSafeTs() uint64 { if m != nil { return m.SafeTs } return 0 } type RecoveryInProgress struct { // The requested region ID RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RecoveryInProgress) Reset() { *m = RecoveryInProgress{} } func (m *RecoveryInProgress) String() string { return proto.CompactTextString(m) } func (*RecoveryInProgress) ProtoMessage() {} func (*RecoveryInProgress) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{14} } func (m *RecoveryInProgress) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RecoveryInProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RecoveryInProgress.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RecoveryInProgress) XXX_Merge(src proto.Message) { xxx_messageInfo_RecoveryInProgress.Merge(dst, src) } func (m *RecoveryInProgress) XXX_Size() int { return m.Size() } func (m *RecoveryInProgress) XXX_DiscardUnknown() { xxx_messageInfo_RecoveryInProgress.DiscardUnknown(m) } var xxx_messageInfo_RecoveryInProgress proto.InternalMessageInfo func (m *RecoveryInProgress) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } // Error wraps all region errors, indicates an error encountered by a request. type Error struct { // The error message Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` NotLeader *NotLeader `protobuf:"bytes,2,opt,name=not_leader,json=notLeader" json:"not_leader,omitempty"` RegionNotFound *RegionNotFound `protobuf:"bytes,3,opt,name=region_not_found,json=regionNotFound" json:"region_not_found,omitempty"` KeyNotInRegion *KeyNotInRegion `protobuf:"bytes,4,opt,name=key_not_in_region,json=keyNotInRegion" json:"key_not_in_region,omitempty"` EpochNotMatch *EpochNotMatch `protobuf:"bytes,5,opt,name=epoch_not_match,json=epochNotMatch" json:"epoch_not_match,omitempty"` ServerIsBusy *ServerIsBusy `protobuf:"bytes,6,opt,name=server_is_busy,json=serverIsBusy" json:"server_is_busy,omitempty"` StaleCommand *StaleCommand `protobuf:"bytes,7,opt,name=stale_command,json=staleCommand" json:"stale_command,omitempty"` StoreNotMatch *StoreNotMatch `protobuf:"bytes,8,opt,name=store_not_match,json=storeNotMatch" json:"store_not_match,omitempty"` RaftEntryTooLarge *RaftEntryTooLarge `protobuf:"bytes,9,opt,name=raft_entry_too_large,json=raftEntryTooLarge" json:"raft_entry_too_large,omitempty"` MaxTimestampNotSynced *MaxTimestampNotSynced `protobuf:"bytes,10,opt,name=max_timestamp_not_synced,json=maxTimestampNotSynced" json:"max_timestamp_not_synced,omitempty"` ReadIndexNotReady *ReadIndexNotReady `protobuf:"bytes,11,opt,name=read_index_not_ready,json=readIndexNotReady" json:"read_index_not_ready,omitempty"` ProposalInMergingMode *ProposalInMergingMode `protobuf:"bytes,12,opt,name=proposal_in_merging_mode,json=proposalInMergingMode" json:"proposal_in_merging_mode,omitempty"` DataIsNotReady *DataIsNotReady `protobuf:"bytes,13,opt,name=data_is_not_ready,json=dataIsNotReady" json:"data_is_not_ready,omitempty"` RegionNotInitialized *RegionNotInitialized `protobuf:"bytes,14,opt,name=region_not_initialized,json=regionNotInitialized" json:"region_not_initialized,omitempty"` DiskFull *DiskFull `protobuf:"bytes,15,opt,name=disk_full,json=diskFull" json:"disk_full,omitempty"` // Online recovery is still in performing, reject writes to avoid potential issues RecoveryInProgress *RecoveryInProgress `protobuf:"bytes,16,opt,name=RecoveryInProgress" json:"RecoveryInProgress,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_errorpb_643166a07278d6aa, []int{15} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetMessage() string { if m != nil { return m.Message } return "" } func (m *Error) GetNotLeader() *NotLeader { if m != nil { return m.NotLeader } return nil } func (m *Error) GetRegionNotFound() *RegionNotFound { if m != nil { return m.RegionNotFound } return nil } func (m *Error) GetKeyNotInRegion() *KeyNotInRegion { if m != nil { return m.KeyNotInRegion } return nil } func (m *Error) GetEpochNotMatch() *EpochNotMatch { if m != nil { return m.EpochNotMatch } return nil } func (m *Error) GetServerIsBusy() *ServerIsBusy { if m != nil { return m.ServerIsBusy } return nil } func (m *Error) GetStaleCommand() *StaleCommand { if m != nil { return m.StaleCommand } return nil } func (m *Error) GetStoreNotMatch() *StoreNotMatch { if m != nil { return m.StoreNotMatch } return nil } func (m *Error) GetRaftEntryTooLarge() *RaftEntryTooLarge { if m != nil { return m.RaftEntryTooLarge } return nil } func (m *Error) GetMaxTimestampNotSynced() *MaxTimestampNotSynced { if m != nil { return m.MaxTimestampNotSynced } return nil } func (m *Error) GetReadIndexNotReady() *ReadIndexNotReady { if m != nil { return m.ReadIndexNotReady } return nil } func (m *Error) GetProposalInMergingMode() *ProposalInMergingMode { if m != nil { return m.ProposalInMergingMode } return nil } func (m *Error) GetDataIsNotReady() *DataIsNotReady { if m != nil { return m.DataIsNotReady } return nil } func (m *Error) GetRegionNotInitialized() *RegionNotInitialized { if m != nil { return m.RegionNotInitialized } return nil } func (m *Error) GetDiskFull() *DiskFull { if m != nil { return m.DiskFull } return nil } func (m *Error) GetRecoveryInProgress() *RecoveryInProgress { if m != nil { return m.RecoveryInProgress } return nil } func init() { proto.RegisterType((*NotLeader)(nil), "errorpb.NotLeader") proto.RegisterType((*DiskFull)(nil), "errorpb.DiskFull") proto.RegisterType((*StoreNotMatch)(nil), "errorpb.StoreNotMatch") proto.RegisterType((*RegionNotFound)(nil), "errorpb.RegionNotFound") proto.RegisterType((*RegionNotInitialized)(nil), "errorpb.RegionNotInitialized") proto.RegisterType((*KeyNotInRegion)(nil), "errorpb.KeyNotInRegion") proto.RegisterType((*EpochNotMatch)(nil), "errorpb.EpochNotMatch") proto.RegisterType((*ServerIsBusy)(nil), "errorpb.ServerIsBusy") proto.RegisterType((*StaleCommand)(nil), "errorpb.StaleCommand") proto.RegisterType((*RaftEntryTooLarge)(nil), "errorpb.RaftEntryTooLarge") proto.RegisterType((*MaxTimestampNotSynced)(nil), "errorpb.MaxTimestampNotSynced") proto.RegisterType((*ReadIndexNotReady)(nil), "errorpb.ReadIndexNotReady") proto.RegisterType((*ProposalInMergingMode)(nil), "errorpb.ProposalInMergingMode") proto.RegisterType((*DataIsNotReady)(nil), "errorpb.DataIsNotReady") proto.RegisterType((*RecoveryInProgress)(nil), "errorpb.RecoveryInProgress") proto.RegisterType((*Error)(nil), "errorpb.Error") } func (m *NotLeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NotLeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.Leader != nil { dAtA[i] = 0x12 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.Leader.Size())) n1, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DiskFull) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DiskFull) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.StoreId) > 0 { dAtA3 := make([]byte, len(m.StoreId)*10) var j2 int for _, num := range m.StoreId { for num >= 1<<7 { dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j2++ } dAtA3[j2] = uint8(num) j2++ } dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(j2)) i += copy(dAtA[i:], dAtA3[:j2]) } if len(m.Reason) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.Reason))) i += copy(dAtA[i:], m.Reason) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreNotMatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreNotMatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RequestStoreId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RequestStoreId)) } if m.ActualStoreId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.ActualStoreId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionNotFound) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionNotFound) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionNotInitialized) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionNotInitialized) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KeyNotInRegion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyNotInRegion) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if len(m.StartKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *EpochNotMatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EpochNotMatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.CurrentRegions) > 0 { for _, msg := range m.CurrentRegions { dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ServerIsBusy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ServerIsBusy) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Reason) > 0 { dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.Reason))) i += copy(dAtA[i:], m.Reason) } if m.BackoffMs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.BackoffMs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StaleCommand) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StaleCommand) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftEntryTooLarge) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftEntryTooLarge) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.EntrySize != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.EntrySize)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MaxTimestampNotSynced) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MaxTimestampNotSynced) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadIndexNotReady) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadIndexNotReady) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Reason) > 0 { dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.Reason))) i += copy(dAtA[i:], m.Reason) } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ProposalInMergingMode) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ProposalInMergingMode) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DataIsNotReady) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DataIsNotReady) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.PeerId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.PeerId)) } if m.SafeTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RecoveryInProgress) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RecoveryInProgress) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Message) > 0 { dAtA[i] = 0xa i++ i = encodeVarintErrorpb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } if m.NotLeader != nil { dAtA[i] = 0x12 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.NotLeader.Size())) n4, err := m.NotLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.RegionNotFound != nil { dAtA[i] = 0x1a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionNotFound.Size())) n5, err := m.RegionNotFound.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.KeyNotInRegion != nil { dAtA[i] = 0x22 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.KeyNotInRegion.Size())) n6, err := m.KeyNotInRegion.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.EpochNotMatch != nil { dAtA[i] = 0x2a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.EpochNotMatch.Size())) n7, err := m.EpochNotMatch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.ServerIsBusy != nil { dAtA[i] = 0x32 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.ServerIsBusy.Size())) n8, err := m.ServerIsBusy.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.StaleCommand != nil { dAtA[i] = 0x3a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.StaleCommand.Size())) n9, err := m.StaleCommand.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.StoreNotMatch != nil { dAtA[i] = 0x42 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.StoreNotMatch.Size())) n10, err := m.StoreNotMatch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.RaftEntryTooLarge != nil { dAtA[i] = 0x4a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RaftEntryTooLarge.Size())) n11, err := m.RaftEntryTooLarge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if m.MaxTimestampNotSynced != nil { dAtA[i] = 0x52 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.MaxTimestampNotSynced.Size())) n12, err := m.MaxTimestampNotSynced.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.ReadIndexNotReady != nil { dAtA[i] = 0x5a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.ReadIndexNotReady.Size())) n13, err := m.ReadIndexNotReady.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.ProposalInMergingMode != nil { dAtA[i] = 0x62 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.ProposalInMergingMode.Size())) n14, err := m.ProposalInMergingMode.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if m.DataIsNotReady != nil { dAtA[i] = 0x6a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.DataIsNotReady.Size())) n15, err := m.DataIsNotReady.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.RegionNotInitialized != nil { dAtA[i] = 0x72 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionNotInitialized.Size())) n16, err := m.RegionNotInitialized.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if m.DiskFull != nil { dAtA[i] = 0x7a i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.DiskFull.Size())) n17, err := m.DiskFull.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if m.RecoveryInProgress != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RecoveryInProgress.Size())) n18, err := m.RecoveryInProgress.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintErrorpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *NotLeader) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DiskFull) Size() (n int) { var l int _ = l if len(m.StoreId) > 0 { l = 0 for _, e := range m.StoreId { l += sovErrorpb(uint64(e)) } n += 1 + sovErrorpb(uint64(l)) + l } l = len(m.Reason) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreNotMatch) Size() (n int) { var l int _ = l if m.RequestStoreId != 0 { n += 1 + sovErrorpb(uint64(m.RequestStoreId)) } if m.ActualStoreId != 0 { n += 1 + sovErrorpb(uint64(m.ActualStoreId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionNotFound) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionNotInitialized) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KeyNotInRegion) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *EpochNotMatch) Size() (n int) { var l int _ = l if len(m.CurrentRegions) > 0 { for _, e := range m.CurrentRegions { l = e.Size() n += 1 + l + sovErrorpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ServerIsBusy) Size() (n int) { var l int _ = l l = len(m.Reason) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.BackoffMs != 0 { n += 1 + sovErrorpb(uint64(m.BackoffMs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StaleCommand) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftEntryTooLarge) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.EntrySize != 0 { n += 1 + sovErrorpb(uint64(m.EntrySize)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MaxTimestampNotSynced) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadIndexNotReady) Size() (n int) { var l int _ = l l = len(m.Reason) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ProposalInMergingMode) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DataIsNotReady) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.PeerId != 0 { n += 1 + sovErrorpb(uint64(m.PeerId)) } if m.SafeTs != 0 { n += 1 + sovErrorpb(uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RecoveryInProgress) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l l = len(m.Message) if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } if m.NotLeader != nil { l = m.NotLeader.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.RegionNotFound != nil { l = m.RegionNotFound.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.KeyNotInRegion != nil { l = m.KeyNotInRegion.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.EpochNotMatch != nil { l = m.EpochNotMatch.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.ServerIsBusy != nil { l = m.ServerIsBusy.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.StaleCommand != nil { l = m.StaleCommand.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.StoreNotMatch != nil { l = m.StoreNotMatch.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.RaftEntryTooLarge != nil { l = m.RaftEntryTooLarge.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.MaxTimestampNotSynced != nil { l = m.MaxTimestampNotSynced.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.ReadIndexNotReady != nil { l = m.ReadIndexNotReady.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.ProposalInMergingMode != nil { l = m.ProposalInMergingMode.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.DataIsNotReady != nil { l = m.DataIsNotReady.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.RegionNotInitialized != nil { l = m.RegionNotInitialized.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.DiskFull != nil { l = m.DiskFull.Size() n += 1 + l + sovErrorpb(uint64(l)) } if m.RecoveryInProgress != nil { l = m.RecoveryInProgress.Size() n += 2 + l + sovErrorpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovErrorpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozErrorpb(x uint64) (n int) { return sovErrorpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *NotLeader) 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 ErrIntOverflowErrorpb } 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: NotLeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NotLeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *DiskFull) 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 ErrIntOverflowErrorpb } 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: DiskFull: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DiskFull: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.StoreId = append(m.StoreId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.StoreId = append(m.StoreId, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } 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 ErrInvalidLengthErrorpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Reason = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *StoreNotMatch) 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 ErrIntOverflowErrorpb } 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: StoreNotMatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreNotMatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RequestStoreId", wireType) } m.RequestStoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RequestStoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ActualStoreId", wireType) } m.ActualStoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ActualStoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *RegionNotFound) 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 ErrIntOverflowErrorpb } 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: RegionNotFound: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionNotFound: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *RegionNotInitialized) 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 ErrIntOverflowErrorpb } 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: RegionNotInitialized: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionNotInitialized: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *KeyNotInRegion) 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 ErrIntOverflowErrorpb } 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: KeyNotInRegion: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyNotInRegion: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *EpochNotMatch) 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 ErrIntOverflowErrorpb } 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: EpochNotMatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EpochNotMatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CurrentRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.CurrentRegions = append(m.CurrentRegions, &metapb.Region{}) if err := m.CurrentRegions[len(m.CurrentRegions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *ServerIsBusy) 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 ErrIntOverflowErrorpb } 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: ServerIsBusy: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ServerIsBusy: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } 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 ErrInvalidLengthErrorpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Reason = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BackoffMs", wireType) } m.BackoffMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BackoffMs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *StaleCommand) 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 ErrIntOverflowErrorpb } 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: StaleCommand: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StaleCommand: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *RaftEntryTooLarge) 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 ErrIntOverflowErrorpb } 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: RaftEntryTooLarge: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftEntryTooLarge: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EntrySize", wireType) } m.EntrySize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EntrySize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *MaxTimestampNotSynced) 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 ErrIntOverflowErrorpb } 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: MaxTimestampNotSynced: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MaxTimestampNotSynced: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *ReadIndexNotReady) 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 ErrIntOverflowErrorpb } 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: ReadIndexNotReady: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadIndexNotReady: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } 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 ErrInvalidLengthErrorpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Reason = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *ProposalInMergingMode) 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 ErrIntOverflowErrorpb } 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: ProposalInMergingMode: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ProposalInMergingMode: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *DataIsNotReady) 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 ErrIntOverflowErrorpb } 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: DataIsNotReady: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DataIsNotReady: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) } m.PeerId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PeerId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafeTs", wireType) } m.SafeTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafeTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *RecoveryInProgress) 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 ErrIntOverflowErrorpb } 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: RecoveryInProgress: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RecoveryInProgress: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 *Error) 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 ErrIntOverflowErrorpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } 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 ErrInvalidLengthErrorpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NotLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.NotLeader == nil { m.NotLeader = &NotLeader{} } if err := m.NotLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionNotFound", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionNotFound == nil { m.RegionNotFound = &RegionNotFound{} } if err := m.RegionNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyNotInRegion", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.KeyNotInRegion == nil { m.KeyNotInRegion = &KeyNotInRegion{} } if err := m.KeyNotInRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EpochNotMatch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.EpochNotMatch == nil { m.EpochNotMatch = &EpochNotMatch{} } if err := m.EpochNotMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ServerIsBusy", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ServerIsBusy == nil { m.ServerIsBusy = &ServerIsBusy{} } if err := m.ServerIsBusy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StaleCommand", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StaleCommand == nil { m.StaleCommand = &StaleCommand{} } if err := m.StaleCommand.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StoreNotMatch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StoreNotMatch == nil { m.StoreNotMatch = &StoreNotMatch{} } if err := m.StoreNotMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RaftEntryTooLarge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RaftEntryTooLarge == nil { m.RaftEntryTooLarge = &RaftEntryTooLarge{} } if err := m.RaftEntryTooLarge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTimestampNotSynced", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MaxTimestampNotSynced == nil { m.MaxTimestampNotSynced = &MaxTimestampNotSynced{} } if err := m.MaxTimestampNotSynced.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIndexNotReady", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReadIndexNotReady == nil { m.ReadIndexNotReady = &ReadIndexNotReady{} } if err := m.ReadIndexNotReady.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ProposalInMergingMode", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ProposalInMergingMode == nil { m.ProposalInMergingMode = &ProposalInMergingMode{} } if err := m.ProposalInMergingMode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DataIsNotReady", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DataIsNotReady == nil { m.DataIsNotReady = &DataIsNotReady{} } if err := m.DataIsNotReady.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionNotInitialized", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionNotInitialized == nil { m.RegionNotInitialized = &RegionNotInitialized{} } if err := m.RegionNotInitialized.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DiskFull", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DiskFull == nil { m.DiskFull = &DiskFull{} } if err := m.DiskFull.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RecoveryInProgress", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowErrorpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthErrorpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RecoveryInProgress == nil { m.RecoveryInProgress = &RecoveryInProgress{} } if err := m.RecoveryInProgress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipErrorpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthErrorpb } 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 skipErrorpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowErrorpb } 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, ErrIntOverflowErrorpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowErrorpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthErrorpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowErrorpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipErrorpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthErrorpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowErrorpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("errorpb.proto", fileDescriptor_errorpb_643166a07278d6aa) } var fileDescriptor_errorpb_643166a07278d6aa = []byte{ // 966 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x96, 0xcd, 0x6e, 0xe3, 0x36, 0x10, 0xc7, 0xeb, 0x24, 0xeb, 0x8f, 0xb1, 0x2d, 0xc7, 0x42, 0x9c, 0xa8, 0x09, 0x62, 0x2c, 0x84, 0x62, 0x91, 0x4b, 0x5d, 0x6c, 0xb6, 0x40, 0x81, 0x16, 0x2d, 0xd0, 0x74, 0xb3, 0x58, 0xc3, 0x6b, 0x37, 0xa0, 0x03, 0xec, 0x51, 0x60, 0xcc, 0xb1, 0x57, 0xb0, 0x24, 0xba, 0x24, 0x15, 0x44, 0x79, 0x92, 0x3e, 0x42, 0xdf, 0xa3, 0x97, 0x1e, 0x7b, 0xec, 0xb1, 0x48, 0x5f, 0xa4, 0x20, 0x25, 0xdb, 0x92, 0xe3, 0xba, 0x27, 0x73, 0x86, 0x33, 0x7f, 0x0e, 0xc5, 0xf9, 0x91, 0x86, 0x26, 0x0a, 0xc1, 0xc5, 0xe2, 0xae, 0xb7, 0x10, 0x5c, 0x71, 0xbb, 0x92, 0x99, 0xa7, 0x8d, 0x10, 0x15, 0x5d, 0xba, 0x4f, 0x8f, 0x66, 0x7c, 0xc6, 0xcd, 0xf0, 0x2b, 0x3d, 0xca, 0xbc, 0x2d, 0x11, 0x4b, 0x65, 0x86, 0xa9, 0xc3, 0x1d, 0x41, 0x6d, 0xc4, 0xd5, 0x07, 0xa4, 0x0c, 0x85, 0x7d, 0x06, 0x35, 0x81, 0x33, 0x9f, 0x47, 0x9e, 0xcf, 0x9c, 0xd2, 0xcb, 0xd2, 0xc5, 0x01, 0xa9, 0xa6, 0x8e, 0x3e, 0xb3, 0xbf, 0x80, 0x72, 0x60, 0xc2, 0x9c, 0xbd, 0x97, 0xa5, 0x8b, 0xfa, 0x65, 0xa3, 0x97, 0xad, 0x77, 0x83, 0x28, 0x48, 0x36, 0xe7, 0x7e, 0x0f, 0xd5, 0xb7, 0xbe, 0x9c, 0xbf, 0x8b, 0x83, 0xc0, 0xfe, 0x1c, 0xaa, 0x52, 0x71, 0x81, 0xa9, 0xda, 0xfe, 0xc5, 0x01, 0xa9, 0x18, 0xbb, 0xcf, 0xec, 0x63, 0x28, 0x0b, 0xa4, 0x92, 0x47, 0x46, 0xac, 0x46, 0x32, 0xcb, 0xa5, 0xd0, 0x1c, 0xeb, 0x90, 0x11, 0x57, 0x43, 0xaa, 0x26, 0x9f, 0xec, 0x0b, 0x38, 0x14, 0xf8, 0x4b, 0x8c, 0x52, 0x79, 0x39, 0x2d, 0x5d, 0x99, 0x95, 0xf9, 0xc7, 0x99, 0xe4, 0x2b, 0x68, 0xd1, 0x89, 0x8a, 0x69, 0xb0, 0x0e, 0xdc, 0x33, 0x81, 0xcd, 0xd4, 0x9d, 0xc5, 0xb9, 0x5f, 0x82, 0x45, 0xcc, 0x9e, 0x46, 0x5c, 0xbd, 0xe3, 0x71, 0xc4, 0x76, 0x6e, 0xdb, 0x7d, 0x03, 0x47, 0xab, 0xf0, 0x7e, 0xe4, 0x2b, 0x9f, 0x06, 0xfe, 0x23, 0xfe, 0x4f, 0x52, 0x0c, 0xd6, 0x00, 0x13, 0x93, 0x91, 0x26, 0xdb, 0x87, 0xb0, 0x3f, 0xc7, 0xc4, 0x04, 0x36, 0x88, 0x1e, 0x16, 0x05, 0xf6, 0x36, 0x3e, 0xf6, 0x19, 0xd4, 0xa4, 0xa2, 0x42, 0x79, 0x3a, 0x69, 0xdf, 0x24, 0x55, 0x8d, 0x63, 0x80, 0x89, 0x7d, 0x02, 0x15, 0x8c, 0x98, 0x99, 0x3a, 0x30, 0x53, 0x65, 0x8c, 0xd8, 0x00, 0x13, 0xf7, 0x3d, 0x34, 0xaf, 0x17, 0x7c, 0xf2, 0x69, 0xf5, 0xf5, 0xbe, 0x81, 0xd6, 0x24, 0x16, 0x02, 0x23, 0xe5, 0xa5, 0xd2, 0xd2, 0x1c, 0x44, 0xfd, 0xd2, 0x5a, 0x1e, 0x5e, 0x5a, 0x1e, 0xb1, 0xb2, 0xb0, 0xd4, 0x94, 0xee, 0x35, 0x34, 0xc6, 0x28, 0xee, 0x51, 0xf4, 0xe5, 0x55, 0x2c, 0x93, 0xdc, 0x79, 0x95, 0xf2, 0xe7, 0x65, 0x9f, 0x03, 0xdc, 0xd1, 0xc9, 0x9c, 0x4f, 0xa7, 0x5e, 0x28, 0xb3, 0x5d, 0xd4, 0x32, 0xcf, 0x50, 0xba, 0x16, 0x34, 0xc6, 0x8a, 0x06, 0xf8, 0x13, 0x0f, 0x43, 0x1a, 0x31, 0xf7, 0x67, 0x68, 0x13, 0x3a, 0x55, 0xd7, 0x91, 0x12, 0xc9, 0x2d, 0xe7, 0x1f, 0xa8, 0x98, 0xe1, 0xee, 0xae, 0x3b, 0x07, 0x40, 0x1d, 0xed, 0x49, 0xff, 0x11, 0x97, 0x0b, 0x18, 0xcf, 0xd8, 0x7f, 0x44, 0xf7, 0x04, 0x3a, 0x43, 0xfa, 0x70, 0xeb, 0x87, 0x28, 0x15, 0x0d, 0x17, 0x23, 0xae, 0xc6, 0x49, 0x34, 0x41, 0xe6, 0xbe, 0x87, 0x36, 0x41, 0xca, 0xfa, 0x11, 0xc3, 0x87, 0x11, 0x57, 0x7a, 0xfc, 0xdf, 0xbb, 0xd8, 0x75, 0x14, 0xee, 0xd7, 0xd0, 0xb9, 0x11, 0x7c, 0xc1, 0x25, 0x0d, 0xfa, 0xd1, 0x10, 0xc5, 0xcc, 0x8f, 0x66, 0x43, 0xce, 0x76, 0xd7, 0xed, 0x7a, 0x60, 0xbd, 0xa5, 0x8a, 0xf6, 0xe5, 0x6a, 0xf1, 0x9d, 0xdb, 0x3c, 0x81, 0xca, 0x02, 0x51, 0xac, 0xd7, 0x2f, 0x6b, 0x33, 0x9d, 0x90, 0x74, 0x8a, 0x9e, 0x92, 0xa6, 0x0d, 0x0e, 0x48, 0x59, 0x9b, 0xb7, 0xd2, 0x7d, 0x0d, 0x36, 0xc1, 0x09, 0xbf, 0x47, 0x91, 0xf4, 0xa3, 0x1b, 0xc1, 0x67, 0x02, 0xa5, 0xdc, 0x5d, 0xd3, 0xef, 0x55, 0x78, 0x71, 0xad, 0x2f, 0x0b, 0xdb, 0x81, 0x4a, 0x88, 0x52, 0xd2, 0x19, 0x66, 0x5f, 0x62, 0x69, 0xda, 0xaf, 0x01, 0x22, 0xae, 0xbc, 0x02, 0xe9, 0x76, 0x6f, 0x79, 0xe3, 0xac, 0xae, 0x0a, 0x52, 0x8b, 0x56, 0xb7, 0xc6, 0x8f, 0x1a, 0x51, 0xb3, 0xa6, 0xce, 0x9c, 0x6a, 0xa4, 0x4c, 0xad, 0xf5, 0xcb, 0x93, 0x55, 0x62, 0x91, 0x38, 0xcd, 0x6e, 0x81, 0xc0, 0x2b, 0x68, 0xcf, 0x31, 0x31, 0xf9, 0x7e, 0x94, 0xb5, 0xaa, 0xe9, 0xed, 0xbc, 0x46, 0x91, 0x28, 0x62, 0xcd, 0x8b, 0x84, 0xfd, 0x00, 0x2d, 0xd4, 0xcd, 0x6f, 0x54, 0x42, 0xdd, 0xfe, 0xce, 0x0b, 0xa3, 0x70, 0xbc, 0x52, 0x28, 0xc0, 0x41, 0x9a, 0x58, 0x60, 0xe5, 0x3b, 0xb0, 0xa4, 0x69, 0x79, 0xcf, 0x97, 0xde, 0x5d, 0x2c, 0x13, 0xa7, 0x6c, 0xd2, 0x3b, 0xab, 0xf4, 0x3c, 0x11, 0xa4, 0x21, 0xf3, 0x7c, 0x7c, 0x0b, 0x4d, 0xa9, 0x1b, 0xdd, 0x9b, 0xa4, 0x9d, 0xee, 0x54, 0x36, 0x73, 0x73, 0x18, 0x90, 0x86, 0xcc, 0x59, 0xba, 0xf0, 0xf4, 0xc6, 0x5a, 0x17, 0x5e, 0xdd, 0x28, 0xbc, 0x70, 0x27, 0x92, 0xa6, 0x2c, 0x5c, 0x91, 0x03, 0x38, 0x12, 0x74, 0xaa, 0xbc, 0x94, 0x13, 0xc5, 0xb9, 0x17, 0x68, 0xae, 0x9c, 0x9a, 0x11, 0x39, 0x5d, 0x9f, 0xc1, 0x26, 0x79, 0xa4, 0x2d, 0x9e, 0xc1, 0xf8, 0x11, 0x9c, 0x90, 0x3e, 0x78, 0x6a, 0x49, 0x94, 0x29, 0x4a, 0x1a, 0xa6, 0x1c, 0x30, 0x82, 0xdd, 0x95, 0xe0, 0x56, 0xf2, 0x48, 0x27, 0xdc, 0xe6, 0x36, 0x55, 0x22, 0x65, 0x9e, 0xaf, 0x89, 0x34, 0xaa, 0xda, 0x4c, 0x9c, 0xfa, 0x66, 0x95, 0x9b, 0xd4, 0x92, 0xb6, 0x78, 0x06, 0xf2, 0x47, 0x70, 0x16, 0x19, 0x93, 0xba, 0x61, 0xc2, 0x94, 0x4a, 0x2f, 0xe4, 0x0c, 0x9d, 0xc6, 0x46, 0x95, 0x5b, 0xe1, 0x25, 0x9d, 0xc5, 0x56, 0xa6, 0xaf, 0xa0, 0xcd, 0xa8, 0xa2, 0xba, 0x05, 0xd6, 0x25, 0x36, 0x37, 0x1a, 0xb1, 0x08, 0x36, 0xb1, 0x58, 0x11, 0xf4, 0x31, 0x1c, 0xe7, 0x78, 0xf0, 0xd7, 0x6f, 0x86, 0x63, 0x19, 0xa1, 0xf3, 0xe7, 0x54, 0xe4, 0x1e, 0x16, 0x72, 0x24, 0xb6, 0x3d, 0x37, 0x3d, 0xa8, 0x31, 0x5f, 0xce, 0xbd, 0x69, 0x1c, 0x04, 0x4e, 0xcb, 0xe8, 0xb4, 0xd7, 0x05, 0x65, 0x2f, 0x2e, 0xa9, 0xb2, 0xe5, 0xdb, 0x3b, 0xd8, 0x76, 0x3d, 0x38, 0x87, 0x26, 0xf1, 0x2c, 0x57, 0xc0, 0x66, 0x08, 0xd9, 0x92, 0x46, 0xea, 0x69, 0x6f, 0x1b, 0x5e, 0xae, 0x5e, 0xfd, 0xf5, 0x5b, 0xb5, 0xf4, 0xc7, 0x53, 0xb7, 0xf4, 0xe7, 0x53, 0xb7, 0xf4, 0xf7, 0x53, 0xb7, 0xf4, 0xeb, 0x3f, 0xdd, 0xcf, 0xe0, 0x90, 0x8b, 0x59, 0x4f, 0xf9, 0xf3, 0xfb, 0xde, 0xfc, 0xde, 0xfc, 0xb3, 0xb8, 0x2b, 0x9b, 0x9f, 0x37, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x63, 0x81, 0x00, 0xca, 0xaf, 0x08, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/import_kvpb/000077500000000000000000000000001421456440000174225ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/import_kvpb/import_kvpb.pb.go000066400000000000000000004102261421456440000227120ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: import_kvpb.proto package import_kvpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" import_sstpb "github.com/pingcap/kvproto/pkg/import_sstpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type Mutation_OP int32 const ( Mutation_Put Mutation_OP = 0 ) var Mutation_OP_name = map[int32]string{ 0: "Put", } var Mutation_OP_value = map[string]int32{ "Put": 0, } func (x Mutation_OP) String() string { return proto.EnumName(Mutation_OP_name, int32(x)) } func (Mutation_OP) EnumDescriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{5, 0} } type SwitchModeRequest struct { PdAddr string `protobuf:"bytes,1,opt,name=pd_addr,json=pdAddr,proto3" json:"pd_addr,omitempty"` Request *import_sstpb.SwitchModeRequest `protobuf:"bytes,2,opt,name=request" json:"request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SwitchModeRequest) Reset() { *m = SwitchModeRequest{} } func (m *SwitchModeRequest) String() string { return proto.CompactTextString(m) } func (*SwitchModeRequest) ProtoMessage() {} func (*SwitchModeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{0} } func (m *SwitchModeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SwitchModeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SwitchModeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SwitchModeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SwitchModeRequest.Merge(dst, src) } func (m *SwitchModeRequest) XXX_Size() int { return m.Size() } func (m *SwitchModeRequest) XXX_DiscardUnknown() { xxx_messageInfo_SwitchModeRequest.DiscardUnknown(m) } var xxx_messageInfo_SwitchModeRequest proto.InternalMessageInfo func (m *SwitchModeRequest) GetPdAddr() string { if m != nil { return m.PdAddr } return "" } func (m *SwitchModeRequest) GetRequest() *import_sstpb.SwitchModeRequest { if m != nil { return m.Request } return nil } type SwitchModeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SwitchModeResponse) Reset() { *m = SwitchModeResponse{} } func (m *SwitchModeResponse) String() string { return proto.CompactTextString(m) } func (*SwitchModeResponse) ProtoMessage() {} func (*SwitchModeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{1} } func (m *SwitchModeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SwitchModeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SwitchModeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SwitchModeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SwitchModeResponse.Merge(dst, src) } func (m *SwitchModeResponse) XXX_Size() int { return m.Size() } func (m *SwitchModeResponse) XXX_DiscardUnknown() { xxx_messageInfo_SwitchModeResponse.DiscardUnknown(m) } var xxx_messageInfo_SwitchModeResponse proto.InternalMessageInfo type OpenEngineRequest struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` KeyPrefix []byte `protobuf:"bytes,2,opt,name=key_prefix,json=keyPrefix,proto3" json:"key_prefix,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *OpenEngineRequest) Reset() { *m = OpenEngineRequest{} } func (m *OpenEngineRequest) String() string { return proto.CompactTextString(m) } func (*OpenEngineRequest) ProtoMessage() {} func (*OpenEngineRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{2} } func (m *OpenEngineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *OpenEngineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_OpenEngineRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *OpenEngineRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_OpenEngineRequest.Merge(dst, src) } func (m *OpenEngineRequest) XXX_Size() int { return m.Size() } func (m *OpenEngineRequest) XXX_DiscardUnknown() { xxx_messageInfo_OpenEngineRequest.DiscardUnknown(m) } var xxx_messageInfo_OpenEngineRequest proto.InternalMessageInfo func (m *OpenEngineRequest) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *OpenEngineRequest) GetKeyPrefix() []byte { if m != nil { return m.KeyPrefix } return nil } type OpenEngineResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *OpenEngineResponse) Reset() { *m = OpenEngineResponse{} } func (m *OpenEngineResponse) String() string { return proto.CompactTextString(m) } func (*OpenEngineResponse) ProtoMessage() {} func (*OpenEngineResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{3} } func (m *OpenEngineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *OpenEngineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_OpenEngineResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *OpenEngineResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_OpenEngineResponse.Merge(dst, src) } func (m *OpenEngineResponse) XXX_Size() int { return m.Size() } func (m *OpenEngineResponse) XXX_DiscardUnknown() { xxx_messageInfo_OpenEngineResponse.DiscardUnknown(m) } var xxx_messageInfo_OpenEngineResponse proto.InternalMessageInfo type WriteHead struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteHead) Reset() { *m = WriteHead{} } func (m *WriteHead) String() string { return proto.CompactTextString(m) } func (*WriteHead) ProtoMessage() {} func (*WriteHead) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{4} } func (m *WriteHead) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteHead) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteHead.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteHead) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteHead.Merge(dst, src) } func (m *WriteHead) XXX_Size() int { return m.Size() } func (m *WriteHead) XXX_DiscardUnknown() { xxx_messageInfo_WriteHead.DiscardUnknown(m) } var xxx_messageInfo_WriteHead proto.InternalMessageInfo func (m *WriteHead) GetUuid() []byte { if m != nil { return m.Uuid } return nil } type Mutation struct { Op Mutation_OP `protobuf:"varint,1,opt,name=op,proto3,enum=import_kvpb.Mutation_OP" json:"op,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Mutation) Reset() { *m = Mutation{} } func (m *Mutation) String() string { return proto.CompactTextString(m) } func (*Mutation) ProtoMessage() {} func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{5} } func (m *Mutation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Mutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Mutation.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Mutation) XXX_Merge(src proto.Message) { xxx_messageInfo_Mutation.Merge(dst, src) } func (m *Mutation) XXX_Size() int { return m.Size() } func (m *Mutation) XXX_DiscardUnknown() { xxx_messageInfo_Mutation.DiscardUnknown(m) } var xxx_messageInfo_Mutation proto.InternalMessageInfo func (m *Mutation) GetOp() Mutation_OP { if m != nil { return m.Op } return Mutation_Put } func (m *Mutation) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *Mutation) GetValue() []byte { if m != nil { return m.Value } return nil } type WriteBatch struct { CommitTs uint64 `protobuf:"varint,1,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteBatch) Reset() { *m = WriteBatch{} } func (m *WriteBatch) String() string { return proto.CompactTextString(m) } func (*WriteBatch) ProtoMessage() {} func (*WriteBatch) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{6} } func (m *WriteBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteBatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteBatch.Merge(dst, src) } func (m *WriteBatch) XXX_Size() int { return m.Size() } func (m *WriteBatch) XXX_DiscardUnknown() { xxx_messageInfo_WriteBatch.DiscardUnknown(m) } var xxx_messageInfo_WriteBatch proto.InternalMessageInfo func (m *WriteBatch) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *WriteBatch) GetMutations() []*Mutation { if m != nil { return m.Mutations } return nil } type WriteEngineRequest struct { // Types that are valid to be assigned to Chunk: // *WriteEngineRequest_Head // *WriteEngineRequest_Batch Chunk isWriteEngineRequest_Chunk `protobuf_oneof:"chunk"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteEngineRequest) Reset() { *m = WriteEngineRequest{} } func (m *WriteEngineRequest) String() string { return proto.CompactTextString(m) } func (*WriteEngineRequest) ProtoMessage() {} func (*WriteEngineRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{7} } func (m *WriteEngineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteEngineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteEngineRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteEngineRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteEngineRequest.Merge(dst, src) } func (m *WriteEngineRequest) XXX_Size() int { return m.Size() } func (m *WriteEngineRequest) XXX_DiscardUnknown() { xxx_messageInfo_WriteEngineRequest.DiscardUnknown(m) } var xxx_messageInfo_WriteEngineRequest proto.InternalMessageInfo type isWriteEngineRequest_Chunk interface { isWriteEngineRequest_Chunk() MarshalTo([]byte) (int, error) Size() int } type WriteEngineRequest_Head struct { Head *WriteHead `protobuf:"bytes,1,opt,name=head,oneof"` } type WriteEngineRequest_Batch struct { Batch *WriteBatch `protobuf:"bytes,2,opt,name=batch,oneof"` } func (*WriteEngineRequest_Head) isWriteEngineRequest_Chunk() {} func (*WriteEngineRequest_Batch) isWriteEngineRequest_Chunk() {} func (m *WriteEngineRequest) GetChunk() isWriteEngineRequest_Chunk { if m != nil { return m.Chunk } return nil } func (m *WriteEngineRequest) GetHead() *WriteHead { if x, ok := m.GetChunk().(*WriteEngineRequest_Head); ok { return x.Head } return nil } func (m *WriteEngineRequest) GetBatch() *WriteBatch { if x, ok := m.GetChunk().(*WriteEngineRequest_Batch); ok { return x.Batch } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*WriteEngineRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _WriteEngineRequest_OneofMarshaler, _WriteEngineRequest_OneofUnmarshaler, _WriteEngineRequest_OneofSizer, []interface{}{ (*WriteEngineRequest_Head)(nil), (*WriteEngineRequest_Batch)(nil), } } func _WriteEngineRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*WriteEngineRequest) // chunk switch x := m.Chunk.(type) { case *WriteEngineRequest_Head: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Head); err != nil { return err } case *WriteEngineRequest_Batch: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Batch); err != nil { return err } case nil: default: return fmt.Errorf("WriteEngineRequest.Chunk has unexpected type %T", x) } return nil } func _WriteEngineRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*WriteEngineRequest) switch tag { case 1: // chunk.head if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(WriteHead) err := b.DecodeMessage(msg) m.Chunk = &WriteEngineRequest_Head{msg} return true, err case 2: // chunk.batch if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(WriteBatch) err := b.DecodeMessage(msg) m.Chunk = &WriteEngineRequest_Batch{msg} return true, err default: return false, nil } } func _WriteEngineRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*WriteEngineRequest) // chunk switch x := m.Chunk.(type) { case *WriteEngineRequest_Head: s := proto.Size(x.Head) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *WriteEngineRequest_Batch: s := proto.Size(x.Batch) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type KVPair struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KVPair) Reset() { *m = KVPair{} } func (m *KVPair) String() string { return proto.CompactTextString(m) } func (*KVPair) ProtoMessage() {} func (*KVPair) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{8} } func (m *KVPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KVPair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KVPair) XXX_Merge(src proto.Message) { xxx_messageInfo_KVPair.Merge(dst, src) } func (m *KVPair) XXX_Size() int { return m.Size() } func (m *KVPair) XXX_DiscardUnknown() { xxx_messageInfo_KVPair.DiscardUnknown(m) } var xxx_messageInfo_KVPair proto.InternalMessageInfo func (m *KVPair) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *KVPair) GetValue() []byte { if m != nil { return m.Value } return nil } type WriteEngineV3Request struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` CommitTs uint64 `protobuf:"varint,2,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` Pairs []*KVPair `protobuf:"bytes,3,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteEngineV3Request) Reset() { *m = WriteEngineV3Request{} } func (m *WriteEngineV3Request) String() string { return proto.CompactTextString(m) } func (*WriteEngineV3Request) ProtoMessage() {} func (*WriteEngineV3Request) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{9} } func (m *WriteEngineV3Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteEngineV3Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteEngineV3Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteEngineV3Request) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteEngineV3Request.Merge(dst, src) } func (m *WriteEngineV3Request) XXX_Size() int { return m.Size() } func (m *WriteEngineV3Request) XXX_DiscardUnknown() { xxx_messageInfo_WriteEngineV3Request.DiscardUnknown(m) } var xxx_messageInfo_WriteEngineV3Request proto.InternalMessageInfo func (m *WriteEngineV3Request) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *WriteEngineV3Request) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *WriteEngineV3Request) GetPairs() []*KVPair { if m != nil { return m.Pairs } return nil } type WriteEngineResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteEngineResponse) Reset() { *m = WriteEngineResponse{} } func (m *WriteEngineResponse) String() string { return proto.CompactTextString(m) } func (*WriteEngineResponse) ProtoMessage() {} func (*WriteEngineResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{10} } func (m *WriteEngineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteEngineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteEngineResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteEngineResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteEngineResponse.Merge(dst, src) } func (m *WriteEngineResponse) XXX_Size() int { return m.Size() } func (m *WriteEngineResponse) XXX_DiscardUnknown() { xxx_messageInfo_WriteEngineResponse.DiscardUnknown(m) } var xxx_messageInfo_WriteEngineResponse proto.InternalMessageInfo func (m *WriteEngineResponse) GetError() *Error { if m != nil { return m.Error } return nil } type CloseEngineRequest struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CloseEngineRequest) Reset() { *m = CloseEngineRequest{} } func (m *CloseEngineRequest) String() string { return proto.CompactTextString(m) } func (*CloseEngineRequest) ProtoMessage() {} func (*CloseEngineRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{11} } func (m *CloseEngineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CloseEngineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CloseEngineRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CloseEngineRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CloseEngineRequest.Merge(dst, src) } func (m *CloseEngineRequest) XXX_Size() int { return m.Size() } func (m *CloseEngineRequest) XXX_DiscardUnknown() { xxx_messageInfo_CloseEngineRequest.DiscardUnknown(m) } var xxx_messageInfo_CloseEngineRequest proto.InternalMessageInfo func (m *CloseEngineRequest) GetUuid() []byte { if m != nil { return m.Uuid } return nil } type CloseEngineResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CloseEngineResponse) Reset() { *m = CloseEngineResponse{} } func (m *CloseEngineResponse) String() string { return proto.CompactTextString(m) } func (*CloseEngineResponse) ProtoMessage() {} func (*CloseEngineResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{12} } func (m *CloseEngineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CloseEngineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CloseEngineResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CloseEngineResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CloseEngineResponse.Merge(dst, src) } func (m *CloseEngineResponse) XXX_Size() int { return m.Size() } func (m *CloseEngineResponse) XXX_DiscardUnknown() { xxx_messageInfo_CloseEngineResponse.DiscardUnknown(m) } var xxx_messageInfo_CloseEngineResponse proto.InternalMessageInfo func (m *CloseEngineResponse) GetError() *Error { if m != nil { return m.Error } return nil } type ImportEngineRequest struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` PdAddr string `protobuf:"bytes,2,opt,name=pd_addr,json=pdAddr,proto3" json:"pd_addr,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImportEngineRequest) Reset() { *m = ImportEngineRequest{} } func (m *ImportEngineRequest) String() string { return proto.CompactTextString(m) } func (*ImportEngineRequest) ProtoMessage() {} func (*ImportEngineRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{13} } func (m *ImportEngineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImportEngineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImportEngineRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ImportEngineRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ImportEngineRequest.Merge(dst, src) } func (m *ImportEngineRequest) XXX_Size() int { return m.Size() } func (m *ImportEngineRequest) XXX_DiscardUnknown() { xxx_messageInfo_ImportEngineRequest.DiscardUnknown(m) } var xxx_messageInfo_ImportEngineRequest proto.InternalMessageInfo func (m *ImportEngineRequest) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *ImportEngineRequest) GetPdAddr() string { if m != nil { return m.PdAddr } return "" } type ImportEngineResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImportEngineResponse) Reset() { *m = ImportEngineResponse{} } func (m *ImportEngineResponse) String() string { return proto.CompactTextString(m) } func (*ImportEngineResponse) ProtoMessage() {} func (*ImportEngineResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{14} } func (m *ImportEngineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImportEngineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImportEngineResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ImportEngineResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ImportEngineResponse.Merge(dst, src) } func (m *ImportEngineResponse) XXX_Size() int { return m.Size() } func (m *ImportEngineResponse) XXX_DiscardUnknown() { xxx_messageInfo_ImportEngineResponse.DiscardUnknown(m) } var xxx_messageInfo_ImportEngineResponse proto.InternalMessageInfo type CleanupEngineRequest struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CleanupEngineRequest) Reset() { *m = CleanupEngineRequest{} } func (m *CleanupEngineRequest) String() string { return proto.CompactTextString(m) } func (*CleanupEngineRequest) ProtoMessage() {} func (*CleanupEngineRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{15} } func (m *CleanupEngineRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CleanupEngineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CleanupEngineRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CleanupEngineRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CleanupEngineRequest.Merge(dst, src) } func (m *CleanupEngineRequest) XXX_Size() int { return m.Size() } func (m *CleanupEngineRequest) XXX_DiscardUnknown() { xxx_messageInfo_CleanupEngineRequest.DiscardUnknown(m) } var xxx_messageInfo_CleanupEngineRequest proto.InternalMessageInfo func (m *CleanupEngineRequest) GetUuid() []byte { if m != nil { return m.Uuid } return nil } type CleanupEngineResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CleanupEngineResponse) Reset() { *m = CleanupEngineResponse{} } func (m *CleanupEngineResponse) String() string { return proto.CompactTextString(m) } func (*CleanupEngineResponse) ProtoMessage() {} func (*CleanupEngineResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{16} } func (m *CleanupEngineResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CleanupEngineResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CleanupEngineResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CleanupEngineResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CleanupEngineResponse.Merge(dst, src) } func (m *CleanupEngineResponse) XXX_Size() int { return m.Size() } func (m *CleanupEngineResponse) XXX_DiscardUnknown() { xxx_messageInfo_CleanupEngineResponse.DiscardUnknown(m) } var xxx_messageInfo_CleanupEngineResponse proto.InternalMessageInfo type CompactClusterRequest struct { PdAddr string `protobuf:"bytes,1,opt,name=pd_addr,json=pdAddr,proto3" json:"pd_addr,omitempty"` Request *import_sstpb.CompactRequest `protobuf:"bytes,2,opt,name=request" json:"request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactClusterRequest) Reset() { *m = CompactClusterRequest{} } func (m *CompactClusterRequest) String() string { return proto.CompactTextString(m) } func (*CompactClusterRequest) ProtoMessage() {} func (*CompactClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{17} } func (m *CompactClusterRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactClusterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactClusterRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactClusterRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactClusterRequest.Merge(dst, src) } func (m *CompactClusterRequest) XXX_Size() int { return m.Size() } func (m *CompactClusterRequest) XXX_DiscardUnknown() { xxx_messageInfo_CompactClusterRequest.DiscardUnknown(m) } var xxx_messageInfo_CompactClusterRequest proto.InternalMessageInfo func (m *CompactClusterRequest) GetPdAddr() string { if m != nil { return m.PdAddr } return "" } func (m *CompactClusterRequest) GetRequest() *import_sstpb.CompactRequest { if m != nil { return m.Request } return nil } type CompactClusterResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactClusterResponse) Reset() { *m = CompactClusterResponse{} } func (m *CompactClusterResponse) String() string { return proto.CompactTextString(m) } func (*CompactClusterResponse) ProtoMessage() {} func (*CompactClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{18} } func (m *CompactClusterResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactClusterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactClusterResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactClusterResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactClusterResponse.Merge(dst, src) } func (m *CompactClusterResponse) XXX_Size() int { return m.Size() } func (m *CompactClusterResponse) XXX_DiscardUnknown() { xxx_messageInfo_CompactClusterResponse.DiscardUnknown(m) } var xxx_messageInfo_CompactClusterResponse proto.InternalMessageInfo type GetVersionRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetVersionRequest) Reset() { *m = GetVersionRequest{} } func (m *GetVersionRequest) String() string { return proto.CompactTextString(m) } func (*GetVersionRequest) ProtoMessage() {} func (*GetVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{19} } func (m *GetVersionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetVersionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetVersionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetVersionRequest.Merge(dst, src) } func (m *GetVersionRequest) XXX_Size() int { return m.Size() } func (m *GetVersionRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetVersionRequest.DiscardUnknown(m) } var xxx_messageInfo_GetVersionRequest proto.InternalMessageInfo type GetVersionResponse struct { Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` Commit string `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetVersionResponse) Reset() { *m = GetVersionResponse{} } func (m *GetVersionResponse) String() string { return proto.CompactTextString(m) } func (*GetVersionResponse) ProtoMessage() {} func (*GetVersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{20} } func (m *GetVersionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetVersionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetVersionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetVersionResponse.Merge(dst, src) } func (m *GetVersionResponse) XXX_Size() int { return m.Size() } func (m *GetVersionResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetVersionResponse.DiscardUnknown(m) } var xxx_messageInfo_GetVersionResponse proto.InternalMessageInfo func (m *GetVersionResponse) GetVersion() string { if m != nil { return m.Version } return "" } func (m *GetVersionResponse) GetCommit() string { if m != nil { return m.Commit } return "" } type GetMetricsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMetricsRequest) Reset() { *m = GetMetricsRequest{} } func (m *GetMetricsRequest) String() string { return proto.CompactTextString(m) } func (*GetMetricsRequest) ProtoMessage() {} func (*GetMetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{21} } func (m *GetMetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMetricsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMetricsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMetricsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMetricsRequest.Merge(dst, src) } func (m *GetMetricsRequest) XXX_Size() int { return m.Size() } func (m *GetMetricsRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetMetricsRequest.DiscardUnknown(m) } var xxx_messageInfo_GetMetricsRequest proto.InternalMessageInfo type GetMetricsResponse struct { Prometheus string `protobuf:"bytes,1,opt,name=prometheus,proto3" json:"prometheus,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMetricsResponse) Reset() { *m = GetMetricsResponse{} } func (m *GetMetricsResponse) String() string { return proto.CompactTextString(m) } func (*GetMetricsResponse) ProtoMessage() {} func (*GetMetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{22} } func (m *GetMetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMetricsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMetricsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMetricsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMetricsResponse.Merge(dst, src) } func (m *GetMetricsResponse) XXX_Size() int { return m.Size() } func (m *GetMetricsResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetMetricsResponse.DiscardUnknown(m) } var xxx_messageInfo_GetMetricsResponse proto.InternalMessageInfo func (m *GetMetricsResponse) GetPrometheus() string { if m != nil { return m.Prometheus } return "" } type Error struct { // This can happen if the client hasn't opened the engine, or the server // restarts while the client is writing or closing. An unclosed engine will // be removed on server restart, so the client should not continue but // restart the previous job in that case. EngineNotFound *Error_EngineNotFound `protobuf:"bytes,1,opt,name=engine_not_found,json=engineNotFound" json:"engine_not_found,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{23} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetEngineNotFound() *Error_EngineNotFound { if m != nil { return m.EngineNotFound } return nil } type Error_EngineNotFound struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error_EngineNotFound) Reset() { *m = Error_EngineNotFound{} } func (m *Error_EngineNotFound) String() string { return proto.CompactTextString(m) } func (*Error_EngineNotFound) ProtoMessage() {} func (*Error_EngineNotFound) Descriptor() ([]byte, []int) { return fileDescriptor_import_kvpb_7450c87f07581b0e, []int{23, 0} } func (m *Error_EngineNotFound) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error_EngineNotFound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error_EngineNotFound.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error_EngineNotFound) XXX_Merge(src proto.Message) { xxx_messageInfo_Error_EngineNotFound.Merge(dst, src) } func (m *Error_EngineNotFound) XXX_Size() int { return m.Size() } func (m *Error_EngineNotFound) XXX_DiscardUnknown() { xxx_messageInfo_Error_EngineNotFound.DiscardUnknown(m) } var xxx_messageInfo_Error_EngineNotFound proto.InternalMessageInfo func (m *Error_EngineNotFound) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func init() { proto.RegisterType((*SwitchModeRequest)(nil), "import_kvpb.SwitchModeRequest") proto.RegisterType((*SwitchModeResponse)(nil), "import_kvpb.SwitchModeResponse") proto.RegisterType((*OpenEngineRequest)(nil), "import_kvpb.OpenEngineRequest") proto.RegisterType((*OpenEngineResponse)(nil), "import_kvpb.OpenEngineResponse") proto.RegisterType((*WriteHead)(nil), "import_kvpb.WriteHead") proto.RegisterType((*Mutation)(nil), "import_kvpb.Mutation") proto.RegisterType((*WriteBatch)(nil), "import_kvpb.WriteBatch") proto.RegisterType((*WriteEngineRequest)(nil), "import_kvpb.WriteEngineRequest") proto.RegisterType((*KVPair)(nil), "import_kvpb.KVPair") proto.RegisterType((*WriteEngineV3Request)(nil), "import_kvpb.WriteEngineV3Request") proto.RegisterType((*WriteEngineResponse)(nil), "import_kvpb.WriteEngineResponse") proto.RegisterType((*CloseEngineRequest)(nil), "import_kvpb.CloseEngineRequest") proto.RegisterType((*CloseEngineResponse)(nil), "import_kvpb.CloseEngineResponse") proto.RegisterType((*ImportEngineRequest)(nil), "import_kvpb.ImportEngineRequest") proto.RegisterType((*ImportEngineResponse)(nil), "import_kvpb.ImportEngineResponse") proto.RegisterType((*CleanupEngineRequest)(nil), "import_kvpb.CleanupEngineRequest") proto.RegisterType((*CleanupEngineResponse)(nil), "import_kvpb.CleanupEngineResponse") proto.RegisterType((*CompactClusterRequest)(nil), "import_kvpb.CompactClusterRequest") proto.RegisterType((*CompactClusterResponse)(nil), "import_kvpb.CompactClusterResponse") proto.RegisterType((*GetVersionRequest)(nil), "import_kvpb.GetVersionRequest") proto.RegisterType((*GetVersionResponse)(nil), "import_kvpb.GetVersionResponse") proto.RegisterType((*GetMetricsRequest)(nil), "import_kvpb.GetMetricsRequest") proto.RegisterType((*GetMetricsResponse)(nil), "import_kvpb.GetMetricsResponse") proto.RegisterType((*Error)(nil), "import_kvpb.Error") proto.RegisterType((*Error_EngineNotFound)(nil), "import_kvpb.Error.EngineNotFound") proto.RegisterEnum("import_kvpb.Mutation_OP", Mutation_OP_name, Mutation_OP_value) } // 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 // Client API for ImportKV service type ImportKVClient interface { // Switch the target cluster to normal/import mode. SwitchMode(ctx context.Context, in *SwitchModeRequest, opts ...grpc.CallOption) (*SwitchModeResponse, error) // Open an engine. OpenEngine(ctx context.Context, in *OpenEngineRequest, opts ...grpc.CallOption) (*OpenEngineResponse, error) // Open a write stream to the engine. WriteEngine(ctx context.Context, opts ...grpc.CallOption) (ImportKV_WriteEngineClient, error) // Write to engine, single message version WriteEngineV3(ctx context.Context, in *WriteEngineV3Request, opts ...grpc.CallOption) (*WriteEngineResponse, error) // Close the engine. CloseEngine(ctx context.Context, in *CloseEngineRequest, opts ...grpc.CallOption) (*CloseEngineResponse, error) // Import the engine to the target cluster. ImportEngine(ctx context.Context, in *ImportEngineRequest, opts ...grpc.CallOption) (*ImportEngineResponse, error) // Clean up the engine. CleanupEngine(ctx context.Context, in *CleanupEngineRequest, opts ...grpc.CallOption) (*CleanupEngineResponse, error) // Compact the target cluster for better performance. CompactCluster(ctx context.Context, in *CompactClusterRequest, opts ...grpc.CallOption) (*CompactClusterResponse, error) // Get current version and commit hash GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) // Get importer metrics GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) } type importKVClient struct { cc *grpc.ClientConn } func NewImportKVClient(cc *grpc.ClientConn) ImportKVClient { return &importKVClient{cc} } func (c *importKVClient) SwitchMode(ctx context.Context, in *SwitchModeRequest, opts ...grpc.CallOption) (*SwitchModeResponse, error) { out := new(SwitchModeResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/SwitchMode", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) OpenEngine(ctx context.Context, in *OpenEngineRequest, opts ...grpc.CallOption) (*OpenEngineResponse, error) { out := new(OpenEngineResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/OpenEngine", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) WriteEngine(ctx context.Context, opts ...grpc.CallOption) (ImportKV_WriteEngineClient, error) { stream, err := c.cc.NewStream(ctx, &_ImportKV_serviceDesc.Streams[0], "/import_kvpb.ImportKV/WriteEngine", opts...) if err != nil { return nil, err } x := &importKVWriteEngineClient{stream} return x, nil } type ImportKV_WriteEngineClient interface { Send(*WriteEngineRequest) error CloseAndRecv() (*WriteEngineResponse, error) grpc.ClientStream } type importKVWriteEngineClient struct { grpc.ClientStream } func (x *importKVWriteEngineClient) Send(m *WriteEngineRequest) error { return x.ClientStream.SendMsg(m) } func (x *importKVWriteEngineClient) CloseAndRecv() (*WriteEngineResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(WriteEngineResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *importKVClient) WriteEngineV3(ctx context.Context, in *WriteEngineV3Request, opts ...grpc.CallOption) (*WriteEngineResponse, error) { out := new(WriteEngineResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/WriteEngineV3", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) CloseEngine(ctx context.Context, in *CloseEngineRequest, opts ...grpc.CallOption) (*CloseEngineResponse, error) { out := new(CloseEngineResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/CloseEngine", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) ImportEngine(ctx context.Context, in *ImportEngineRequest, opts ...grpc.CallOption) (*ImportEngineResponse, error) { out := new(ImportEngineResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/ImportEngine", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) CleanupEngine(ctx context.Context, in *CleanupEngineRequest, opts ...grpc.CallOption) (*CleanupEngineResponse, error) { out := new(CleanupEngineResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/CleanupEngine", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) CompactCluster(ctx context.Context, in *CompactClusterRequest, opts ...grpc.CallOption) (*CompactClusterResponse, error) { out := new(CompactClusterResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/CompactCluster", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) { out := new(GetVersionResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/GetVersion", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importKVClient) GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) { out := new(GetMetricsResponse) err := c.cc.Invoke(ctx, "/import_kvpb.ImportKV/GetMetrics", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for ImportKV service type ImportKVServer interface { // Switch the target cluster to normal/import mode. SwitchMode(context.Context, *SwitchModeRequest) (*SwitchModeResponse, error) // Open an engine. OpenEngine(context.Context, *OpenEngineRequest) (*OpenEngineResponse, error) // Open a write stream to the engine. WriteEngine(ImportKV_WriteEngineServer) error // Write to engine, single message version WriteEngineV3(context.Context, *WriteEngineV3Request) (*WriteEngineResponse, error) // Close the engine. CloseEngine(context.Context, *CloseEngineRequest) (*CloseEngineResponse, error) // Import the engine to the target cluster. ImportEngine(context.Context, *ImportEngineRequest) (*ImportEngineResponse, error) // Clean up the engine. CleanupEngine(context.Context, *CleanupEngineRequest) (*CleanupEngineResponse, error) // Compact the target cluster for better performance. CompactCluster(context.Context, *CompactClusterRequest) (*CompactClusterResponse, error) // Get current version and commit hash GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) // Get importer metrics GetMetrics(context.Context, *GetMetricsRequest) (*GetMetricsResponse, error) } func RegisterImportKVServer(s *grpc.Server, srv ImportKVServer) { s.RegisterService(&_ImportKV_serviceDesc, srv) } func _ImportKV_SwitchMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SwitchModeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).SwitchMode(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/SwitchMode", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).SwitchMode(ctx, req.(*SwitchModeRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_OpenEngine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(OpenEngineRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).OpenEngine(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/OpenEngine", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).OpenEngine(ctx, req.(*OpenEngineRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_WriteEngine_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ImportKVServer).WriteEngine(&importKVWriteEngineServer{stream}) } type ImportKV_WriteEngineServer interface { SendAndClose(*WriteEngineResponse) error Recv() (*WriteEngineRequest, error) grpc.ServerStream } type importKVWriteEngineServer struct { grpc.ServerStream } func (x *importKVWriteEngineServer) SendAndClose(m *WriteEngineResponse) error { return x.ServerStream.SendMsg(m) } func (x *importKVWriteEngineServer) Recv() (*WriteEngineRequest, error) { m := new(WriteEngineRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _ImportKV_WriteEngineV3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(WriteEngineV3Request) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).WriteEngineV3(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/WriteEngineV3", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).WriteEngineV3(ctx, req.(*WriteEngineV3Request)) } return interceptor(ctx, in, info, handler) } func _ImportKV_CloseEngine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CloseEngineRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).CloseEngine(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/CloseEngine", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).CloseEngine(ctx, req.(*CloseEngineRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_ImportEngine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ImportEngineRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).ImportEngine(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/ImportEngine", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).ImportEngine(ctx, req.(*ImportEngineRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_CleanupEngine_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CleanupEngineRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).CleanupEngine(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/CleanupEngine", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).CleanupEngine(ctx, req.(*CleanupEngineRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_CompactCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CompactClusterRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).CompactCluster(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/CompactCluster", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).CompactCluster(ctx, req.(*CompactClusterRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetVersionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).GetVersion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/GetVersion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).GetVersion(ctx, req.(*GetVersionRequest)) } return interceptor(ctx, in, info, handler) } func _ImportKV_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetMetricsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportKVServer).GetMetrics(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_kvpb.ImportKV/GetMetrics", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportKVServer).GetMetrics(ctx, req.(*GetMetricsRequest)) } return interceptor(ctx, in, info, handler) } var _ImportKV_serviceDesc = grpc.ServiceDesc{ ServiceName: "import_kvpb.ImportKV", HandlerType: (*ImportKVServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "SwitchMode", Handler: _ImportKV_SwitchMode_Handler, }, { MethodName: "OpenEngine", Handler: _ImportKV_OpenEngine_Handler, }, { MethodName: "WriteEngineV3", Handler: _ImportKV_WriteEngineV3_Handler, }, { MethodName: "CloseEngine", Handler: _ImportKV_CloseEngine_Handler, }, { MethodName: "ImportEngine", Handler: _ImportKV_ImportEngine_Handler, }, { MethodName: "CleanupEngine", Handler: _ImportKV_CleanupEngine_Handler, }, { MethodName: "CompactCluster", Handler: _ImportKV_CompactCluster_Handler, }, { MethodName: "GetVersion", Handler: _ImportKV_GetVersion_Handler, }, { MethodName: "GetMetrics", Handler: _ImportKV_GetMetrics_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "WriteEngine", Handler: _ImportKV_WriteEngine_Handler, ClientStreams: true, }, }, Metadata: "import_kvpb.proto", } func (m *SwitchModeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SwitchModeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.PdAddr) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.PdAddr))) i += copy(dAtA[i:], m.PdAddr) } if m.Request != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Request.Size())) n1, err := m.Request.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SwitchModeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SwitchModeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *OpenEngineRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *OpenEngineRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if len(m.KeyPrefix) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.KeyPrefix))) i += copy(dAtA[i:], m.KeyPrefix) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *OpenEngineResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *OpenEngineResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteHead) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteHead) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Mutation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Mutation) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Op != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Op)) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteBatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteBatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CommitTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.CommitTs)) } if len(m.Mutations) > 0 { for _, msg := range m.Mutations { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteEngineRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteEngineRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Chunk != nil { nn2, err := m.Chunk.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn2 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteEngineRequest_Head) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Head != nil { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Head.Size())) n3, err := m.Head.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } return i, nil } func (m *WriteEngineRequest_Batch) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Batch != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Batch.Size())) n4, err := m.Batch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } return i, nil } func (m *KVPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KVPair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteEngineV3Request) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteEngineV3Request) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.CommitTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.CommitTs)) } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x1a i++ i = encodeVarintImportKvpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteEngineResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteEngineResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Error.Size())) n5, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CloseEngineRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CloseEngineRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CloseEngineResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CloseEngineResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Error.Size())) n6, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ImportEngineRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImportEngineRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if len(m.PdAddr) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.PdAddr))) i += copy(dAtA[i:], m.PdAddr) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ImportEngineResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImportEngineResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CleanupEngineRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CleanupEngineRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CleanupEngineResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CleanupEngineResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactClusterRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactClusterRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.PdAddr) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.PdAddr))) i += copy(dAtA[i:], m.PdAddr) } if m.Request != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.Request.Size())) n7, err := m.Request.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactClusterResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactClusterResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetVersionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetVersionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetVersionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetVersionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Version) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Version))) i += copy(dAtA[i:], m.Version) } if len(m.Commit) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Commit))) i += copy(dAtA[i:], m.Commit) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMetricsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMetricsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMetricsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMetricsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Prometheus) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Prometheus))) i += copy(dAtA[i:], m.Prometheus) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.EngineNotFound != nil { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(m.EngineNotFound.Size())) n8, err := m.EngineNotFound.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error_EngineNotFound) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error_EngineNotFound) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportKvpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintImportKvpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *SwitchModeRequest) Size() (n int) { var l int _ = l l = len(m.PdAddr) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.Request != nil { l = m.Request.Size() n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SwitchModeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *OpenEngineRequest) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } l = len(m.KeyPrefix) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *OpenEngineResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteHead) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Mutation) Size() (n int) { var l int _ = l if m.Op != 0 { n += 1 + sovImportKvpb(uint64(m.Op)) } l = len(m.Key) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteBatch) Size() (n int) { var l int _ = l if m.CommitTs != 0 { n += 1 + sovImportKvpb(uint64(m.CommitTs)) } if len(m.Mutations) > 0 { for _, e := range m.Mutations { l = e.Size() n += 1 + l + sovImportKvpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteEngineRequest) Size() (n int) { var l int _ = l if m.Chunk != nil { n += m.Chunk.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteEngineRequest_Head) Size() (n int) { var l int _ = l if m.Head != nil { l = m.Head.Size() n += 1 + l + sovImportKvpb(uint64(l)) } return n } func (m *WriteEngineRequest_Batch) Size() (n int) { var l int _ = l if m.Batch != nil { l = m.Batch.Size() n += 1 + l + sovImportKvpb(uint64(l)) } return n } func (m *KVPair) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteEngineV3Request) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.CommitTs != 0 { n += 1 + sovImportKvpb(uint64(m.CommitTs)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovImportKvpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteEngineResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CloseEngineRequest) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CloseEngineResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImportEngineRequest) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } l = len(m.PdAddr) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImportEngineResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CleanupEngineRequest) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CleanupEngineResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactClusterRequest) Size() (n int) { var l int _ = l l = len(m.PdAddr) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.Request != nil { l = m.Request.Size() n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactClusterResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetVersionRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetVersionResponse) Size() (n int) { var l int _ = l l = len(m.Version) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } l = len(m.Commit) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMetricsRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMetricsResponse) Size() (n int) { var l int _ = l l = len(m.Prometheus) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l if m.EngineNotFound != nil { l = m.EngineNotFound.Size() n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error_EngineNotFound) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportKvpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovImportKvpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozImportKvpb(x uint64) (n int) { return sovImportKvpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *SwitchModeRequest) 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 ErrIntOverflowImportKvpb } 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: SwitchModeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SwitchModeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PdAddr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PdAddr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Request == nil { m.Request = &import_sstpb.SwitchModeRequest{} } if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *SwitchModeResponse) 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 ErrIntOverflowImportKvpb } 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: SwitchModeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SwitchModeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *OpenEngineRequest) 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 ErrIntOverflowImportKvpb } 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: OpenEngineRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: OpenEngineRequest: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyPrefix", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.KeyPrefix = append(m.KeyPrefix[:0], dAtA[iNdEx:postIndex]...) if m.KeyPrefix == nil { m.KeyPrefix = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *OpenEngineResponse) 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 ErrIntOverflowImportKvpb } 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: OpenEngineResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: OpenEngineResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *WriteHead) 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 ErrIntOverflowImportKvpb } 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: WriteHead: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteHead: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *Mutation) 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 ErrIntOverflowImportKvpb } 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: Mutation: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Mutation: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType) } m.Op = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Op |= (Mutation_OP(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *WriteBatch) 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 ErrIntOverflowImportKvpb } 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: WriteBatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteBatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Mutations = append(m.Mutations, &Mutation{}) if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *WriteEngineRequest) 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 ErrIntOverflowImportKvpb } 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: WriteEngineRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteEngineRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &WriteHead{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &WriteEngineRequest_Head{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &WriteBatch{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &WriteEngineRequest_Batch{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *KVPair) 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 ErrIntOverflowImportKvpb } 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: KVPair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KVPair: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *WriteEngineV3Request) 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 ErrIntOverflowImportKvpb } 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: WriteEngineV3Request: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteEngineV3Request: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KVPair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *WriteEngineResponse) 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 ErrIntOverflowImportKvpb } 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: WriteEngineResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteEngineResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CloseEngineRequest) 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 ErrIntOverflowImportKvpb } 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: CloseEngineRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CloseEngineRequest: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CloseEngineResponse) 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 ErrIntOverflowImportKvpb } 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: CloseEngineResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CloseEngineResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *ImportEngineRequest) 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 ErrIntOverflowImportKvpb } 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: ImportEngineRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImportEngineRequest: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PdAddr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PdAddr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *ImportEngineResponse) 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 ErrIntOverflowImportKvpb } 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: ImportEngineResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImportEngineResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CleanupEngineRequest) 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 ErrIntOverflowImportKvpb } 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: CleanupEngineRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CleanupEngineRequest: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CleanupEngineResponse) 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 ErrIntOverflowImportKvpb } 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: CleanupEngineResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CleanupEngineResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CompactClusterRequest) 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 ErrIntOverflowImportKvpb } 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: CompactClusterRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactClusterRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PdAddr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PdAddr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Request == nil { m.Request = &import_sstpb.CompactRequest{} } if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *CompactClusterResponse) 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 ErrIntOverflowImportKvpb } 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: CompactClusterResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactClusterResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *GetVersionRequest) 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 ErrIntOverflowImportKvpb } 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: GetVersionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *GetVersionResponse) 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 ErrIntOverflowImportKvpb } 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: GetVersionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetVersionResponse: 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 ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen 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 Commit", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Commit = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *GetMetricsRequest) 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 ErrIntOverflowImportKvpb } 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: GetMetricsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *GetMetricsResponse) 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 ErrIntOverflowImportKvpb } 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: GetMetricsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prometheus", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } 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 ErrInvalidLengthImportKvpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Prometheus = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *Error) 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 ErrIntOverflowImportKvpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EngineNotFound", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.EngineNotFound == nil { m.EngineNotFound = &Error_EngineNotFound{} } if err := m.EngineNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 *Error_EngineNotFound) 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 ErrIntOverflowImportKvpb } 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: EngineNotFound: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EngineNotFound: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportKvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportKvpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportKvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportKvpb } 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 skipImportKvpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportKvpb } 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, ErrIntOverflowImportKvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportKvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthImportKvpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportKvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipImportKvpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthImportKvpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowImportKvpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("import_kvpb.proto", fileDescriptor_import_kvpb_7450c87f07581b0e) } var fileDescriptor_import_kvpb_7450c87f07581b0e = []byte{ // 884 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xd1, 0x6e, 0xf3, 0x34, 0x18, 0x4d, 0xd2, 0xb5, 0x5d, 0xbf, 0x6e, 0x63, 0xf3, 0xba, 0x2d, 0x2a, 0xd0, 0x6d, 0x01, 0xa1, 0x82, 0x50, 0x7f, 0xd4, 0x21, 0x24, 0xae, 0x10, 0xad, 0xfe, 0x31, 0x34, 0x8d, 0x56, 0xe1, 0xa7, 0x20, 0x21, 0x51, 0x65, 0x8d, 0xd7, 0x46, 0x69, 0xe3, 0xe0, 0x38, 0x85, 0x21, 0x1e, 0x84, 0x47, 0xe0, 0x51, 0xb8, 0xe4, 0x92, 0x2b, 0x84, 0xc6, 0x8b, 0xa0, 0x38, 0x4e, 0x1b, 0x27, 0x59, 0xcb, 0x7f, 0x35, 0xfb, 0xf3, 0xc9, 0xf9, 0xbe, 0x1e, 0xfb, 0x1c, 0x0d, 0x8e, 0x9c, 0x85, 0x4f, 0x28, 0x1b, 0xbb, 0x4b, 0xff, 0xbe, 0xe3, 0x53, 0xc2, 0x08, 0xaa, 0xa7, 0x4a, 0x4d, 0x24, 0x36, 0x41, 0xc0, 0x12, 0x40, 0xb3, 0x31, 0x25, 0x53, 0xc2, 0x97, 0x2f, 0xa2, 0x95, 0xa8, 0xbe, 0x41, 0xc3, 0x80, 0xf1, 0x65, 0x5c, 0x30, 0xa6, 0x70, 0xf4, 0xf5, 0x4f, 0x0e, 0x9b, 0xcc, 0xee, 0x88, 0x8d, 0x4d, 0xfc, 0x63, 0x88, 0x03, 0x86, 0xce, 0xa0, 0xea, 0xdb, 0x63, 0xcb, 0xb6, 0xa9, 0xae, 0x5e, 0xa8, 0xed, 0x9a, 0x59, 0xf1, 0xed, 0xcf, 0x6d, 0x9b, 0xa2, 0x4f, 0xa1, 0x4a, 0x63, 0x8c, 0xae, 0x5d, 0xa8, 0xed, 0x7a, 0xf7, 0xbc, 0x23, 0xb5, 0xce, 0x51, 0x99, 0x09, 0xde, 0x68, 0x00, 0x4a, 0x9f, 0x06, 0x3e, 0xf1, 0x02, 0x6c, 0x5c, 0xc3, 0xd1, 0xc0, 0xc7, 0xde, 0x4b, 0x6f, 0xea, 0x78, 0xab, 0xf6, 0x08, 0x76, 0xc2, 0xd0, 0xb1, 0x79, 0xef, 0x3d, 0x93, 0xaf, 0xd1, 0xdb, 0x00, 0x2e, 0x7e, 0x1c, 0xfb, 0x14, 0x3f, 0x38, 0x3f, 0xf3, 0xe6, 0x7b, 0x66, 0xcd, 0xc5, 0x8f, 0x43, 0x5e, 0x88, 0xd8, 0xd3, 0x3c, 0x82, 0xfd, 0x1c, 0x6a, 0xdf, 0x52, 0x87, 0xe1, 0x1b, 0x6c, 0xd9, 0x45, 0xac, 0x86, 0x0b, 0xbb, 0x77, 0x21, 0xb3, 0x98, 0x43, 0x3c, 0xd4, 0x06, 0x8d, 0xf8, 0xfc, 0xf4, 0xa0, 0xab, 0x77, 0xd2, 0x8a, 0x27, 0x90, 0xce, 0x60, 0x68, 0x6a, 0xc4, 0x47, 0x87, 0x50, 0x72, 0xf1, 0xa3, 0x18, 0x22, 0x5a, 0xa2, 0x06, 0x94, 0x97, 0xd6, 0x3c, 0xc4, 0x7a, 0x89, 0xd7, 0xe2, 0x8d, 0xb1, 0x0f, 0xda, 0x60, 0x88, 0xaa, 0x50, 0x1a, 0x86, 0xec, 0x50, 0x31, 0x7e, 0x00, 0xe0, 0xd3, 0xf4, 0x2c, 0x36, 0x99, 0xa1, 0x37, 0xa1, 0x36, 0x21, 0x8b, 0x85, 0xc3, 0xc6, 0x2c, 0xe0, 0x5d, 0x77, 0xcc, 0xdd, 0xb8, 0xf0, 0x2a, 0x40, 0x57, 0x50, 0x5b, 0x88, 0xa6, 0x81, 0xae, 0x5d, 0x94, 0xda, 0xf5, 0xee, 0x49, 0xe1, 0x48, 0xe6, 0x1a, 0x67, 0xfc, 0x0a, 0x88, 0xf3, 0xcb, 0x62, 0x7e, 0x08, 0x3b, 0x33, 0x6c, 0xc5, 0x3f, 0xbb, 0xde, 0x3d, 0x95, 0x58, 0x56, 0xe2, 0xdc, 0x28, 0x26, 0x47, 0xa1, 0x17, 0x50, 0xbe, 0x8f, 0xc6, 0x13, 0xd7, 0x7b, 0x96, 0x87, 0xf3, 0xe9, 0x6f, 0x14, 0x33, 0xc6, 0xf5, 0xaa, 0x50, 0x9e, 0xcc, 0x42, 0xcf, 0x35, 0x3e, 0x82, 0xca, 0xed, 0x68, 0x68, 0x39, 0x34, 0x91, 0x47, 0x2d, 0x90, 0x47, 0x4b, 0xcb, 0x43, 0xa1, 0x91, 0x9a, 0x77, 0x74, 0xb5, 0xe9, 0xfa, 0x25, 0xb5, 0xb4, 0x8c, 0x5a, 0xef, 0x43, 0xd9, 0xb7, 0x1c, 0x1a, 0xe8, 0x25, 0xae, 0xd4, 0xb1, 0x34, 0x74, 0x3c, 0x94, 0x19, 0x23, 0x8c, 0xcf, 0xe0, 0x58, 0xd2, 0x28, 0x7e, 0x28, 0xa8, 0x0d, 0x65, 0x4c, 0x29, 0xa1, 0x42, 0x25, 0x24, 0x31, 0xbc, 0x8c, 0x4e, 0xcc, 0x18, 0x60, 0xb4, 0x01, 0xf5, 0xe7, 0x24, 0xc0, 0x5b, 0x5f, 0x6c, 0xd4, 0x4a, 0x42, 0xbe, 0x76, 0xab, 0x1e, 0x1c, 0x7f, 0xc9, 0xcf, 0xb6, 0xbb, 0x23, 0x65, 0x58, 0x2d, 0x6d, 0x58, 0xe3, 0x14, 0x1a, 0x32, 0x87, 0x70, 0xc6, 0x07, 0xd0, 0xe8, 0xcf, 0xb1, 0xe5, 0x85, 0xfe, 0xf6, 0x1f, 0x72, 0x06, 0x27, 0x19, 0xac, 0x20, 0x99, 0xc1, 0x49, 0x9f, 0x2c, 0x7c, 0x6b, 0xc2, 0xfa, 0xf3, 0x30, 0x60, 0x98, 0x6e, 0xcd, 0x8f, 0x4f, 0xb2, 0xf9, 0xf1, 0x96, 0x9c, 0x1f, 0x82, 0x2e, 0x17, 0x1e, 0x3a, 0x9c, 0x66, 0x3b, 0x89, 0x19, 0x8e, 0xe1, 0xe8, 0x0b, 0xcc, 0x46, 0x98, 0x06, 0x91, 0x1b, 0x04, 0xfc, 0x1a, 0x50, 0xba, 0x28, 0x94, 0xd7, 0xa1, 0xba, 0x8c, 0x4b, 0x62, 0xaa, 0x64, 0x8b, 0x4e, 0xa1, 0x12, 0x3f, 0xa6, 0x44, 0xbd, 0x78, 0x27, 0xc8, 0xef, 0x30, 0xa3, 0xce, 0x24, 0x48, 0xc8, 0x3f, 0xe6, 0xe4, 0xab, 0xa2, 0x20, 0x6f, 0x01, 0xf8, 0x94, 0x2c, 0x30, 0x9b, 0xe1, 0x30, 0x10, 0xfc, 0xa9, 0x8a, 0xf1, 0x0b, 0x94, 0xf9, 0xe5, 0xa2, 0x5b, 0x38, 0xc4, 0x5c, 0xc6, 0xb1, 0x47, 0xd8, 0xf8, 0x81, 0x84, 0x5e, 0xe2, 0xcd, 0xcb, 0xfc, 0x53, 0xe8, 0xc4, 0x8a, 0x7f, 0x45, 0xd8, 0x75, 0x04, 0x34, 0x0f, 0xb0, 0xb4, 0x6f, 0xbe, 0x0b, 0x07, 0x32, 0xa2, 0xe8, 0x02, 0xbb, 0x7f, 0x57, 0x60, 0x37, 0x7e, 0x05, 0xb7, 0x23, 0x34, 0x00, 0x58, 0xe7, 0x30, 0x6a, 0x49, 0x3d, 0x73, 0xf1, 0xdd, 0x3c, 0x7f, 0xf6, 0x5c, 0xe8, 0xaf, 0x44, 0x84, 0xeb, 0xe8, 0xcd, 0x10, 0xe6, 0xb2, 0x3d, 0x43, 0x58, 0x90, 0xd9, 0x0a, 0x7a, 0x05, 0xf5, 0x94, 0x47, 0xd1, 0x79, 0x3e, 0x83, 0x64, 0xca, 0x8b, 0xe7, 0x01, 0x09, 0x67, 0x5b, 0x45, 0x23, 0xd8, 0x97, 0xd2, 0x06, 0x5d, 0x3e, 0xf7, 0xd9, 0x2a, 0x89, 0xfe, 0x0f, 0x33, 0x32, 0xa1, 0x9e, 0xb2, 0x79, 0x66, 0xda, 0x7c, 0x54, 0x64, 0x38, 0x0b, 0x12, 0xc2, 0x50, 0xd0, 0x37, 0xb0, 0x97, 0x76, 0x2d, 0x92, 0xbf, 0x29, 0x08, 0x85, 0xe6, 0xe5, 0x06, 0xc4, 0x8a, 0xf6, 0x3b, 0xd8, 0x97, 0x8c, 0x9c, 0x91, 0xa0, 0x28, 0x10, 0x9a, 0xc6, 0x26, 0xc8, 0x8a, 0xf9, 0x7b, 0x38, 0x90, 0xfd, 0x89, 0x32, 0xdf, 0x15, 0xc5, 0x44, 0xf3, 0x9d, 0x8d, 0x98, 0xf4, 0x03, 0x5b, 0xbb, 0x39, 0xf3, 0xc0, 0x72, 0xde, 0xcf, 0x3c, 0xb0, 0x7c, 0x0c, 0xac, 0x08, 0x85, 0x83, 0xf3, 0x84, 0xb2, 0xdf, 0xf3, 0x84, 0x19, 0xeb, 0x1b, 0x4a, 0xef, 0xbd, 0xbf, 0x7e, 0xdf, 0x55, 0xff, 0x78, 0x6a, 0xa9, 0x7f, 0x3e, 0xb5, 0xd4, 0x7f, 0x9e, 0x5a, 0xea, 0x6f, 0xff, 0xb6, 0x14, 0x38, 0x24, 0x74, 0xda, 0x61, 0x8e, 0xbb, 0xec, 0xb8, 0x4b, 0xfe, 0xcf, 0xd6, 0x7d, 0x85, 0xff, 0xb9, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4a, 0x28, 0xa0, 0xd0, 0x09, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/import_sstpb/000077500000000000000000000000001421456440000176135ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/import_sstpb/import_sstpb.pb.go000066400000000000000000005655531421456440000233120ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: import_sstpb.proto package import_sstpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" brpb "github.com/pingcap/kvproto/pkg/brpb" errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" metapb "github.com/pingcap/kvproto/pkg/metapb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type SwitchMode int32 const ( SwitchMode_Normal SwitchMode = 0 SwitchMode_Import SwitchMode = 1 ) var SwitchMode_name = map[int32]string{ 0: "Normal", 1: "Import", } var SwitchMode_value = map[string]int32{ "Normal": 0, "Import": 1, } func (x SwitchMode) String() string { return proto.EnumName(SwitchMode_name, int32(x)) } func (SwitchMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{0} } type Pair_OP int32 const ( Pair_Put Pair_OP = 0 Pair_Delete Pair_OP = 1 ) var Pair_OP_name = map[int32]string{ 0: "Put", 1: "Delete", } var Pair_OP_value = map[string]int32{ "Put": 0, "Delete": 1, } func (x Pair_OP) String() string { return proto.EnumName(Pair_OP_name, int32(x)) } func (Pair_OP) EnumDescriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{17, 0} } type SwitchModeRequest struct { Mode SwitchMode `protobuf:"varint,1,opt,name=mode,proto3,enum=import_sstpb.SwitchMode" json:"mode,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SwitchModeRequest) Reset() { *m = SwitchModeRequest{} } func (m *SwitchModeRequest) String() string { return proto.CompactTextString(m) } func (*SwitchModeRequest) ProtoMessage() {} func (*SwitchModeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{0} } func (m *SwitchModeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SwitchModeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SwitchModeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SwitchModeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SwitchModeRequest.Merge(dst, src) } func (m *SwitchModeRequest) XXX_Size() int { return m.Size() } func (m *SwitchModeRequest) XXX_DiscardUnknown() { xxx_messageInfo_SwitchModeRequest.DiscardUnknown(m) } var xxx_messageInfo_SwitchModeRequest proto.InternalMessageInfo func (m *SwitchModeRequest) GetMode() SwitchMode { if m != nil { return m.Mode } return SwitchMode_Normal } type SwitchModeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SwitchModeResponse) Reset() { *m = SwitchModeResponse{} } func (m *SwitchModeResponse) String() string { return proto.CompactTextString(m) } func (*SwitchModeResponse) ProtoMessage() {} func (*SwitchModeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{1} } func (m *SwitchModeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SwitchModeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SwitchModeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SwitchModeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SwitchModeResponse.Merge(dst, src) } func (m *SwitchModeResponse) XXX_Size() int { return m.Size() } func (m *SwitchModeResponse) XXX_DiscardUnknown() { xxx_messageInfo_SwitchModeResponse.DiscardUnknown(m) } var xxx_messageInfo_SwitchModeResponse proto.InternalMessageInfo type Range struct { Start []byte `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Range) Reset() { *m = Range{} } func (m *Range) String() string { return proto.CompactTextString(m) } func (*Range) ProtoMessage() {} func (*Range) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{2} } func (m *Range) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Range.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Range) XXX_Merge(src proto.Message) { xxx_messageInfo_Range.Merge(dst, src) } func (m *Range) XXX_Size() int { return m.Size() } func (m *Range) XXX_DiscardUnknown() { xxx_messageInfo_Range.DiscardUnknown(m) } var xxx_messageInfo_Range proto.InternalMessageInfo func (m *Range) GetStart() []byte { if m != nil { return m.Start } return nil } func (m *Range) GetEnd() []byte { if m != nil { return m.End } return nil } type SSTMeta struct { Uuid []byte `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"` Range *Range `protobuf:"bytes,2,opt,name=range" json:"range,omitempty"` Crc32 uint32 `protobuf:"varint,3,opt,name=crc32,proto3" json:"crc32,omitempty"` Length uint64 `protobuf:"varint,4,opt,name=length,proto3" json:"length,omitempty"` CfName string `protobuf:"bytes,5,opt,name=cf_name,json=cfName,proto3" json:"cf_name,omitempty"` RegionId uint64 `protobuf:"varint,6,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,7,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` EndKeyExclusive bool `protobuf:"varint,8,opt,name=end_key_exclusive,json=endKeyExclusive,proto3" json:"end_key_exclusive,omitempty"` // total_kvs and total_bytes is equivalent to PD's approximate_keys and approximate_size // set these values can save time from tikv upload keys and size to PD through Heartbeat. TotalKvs uint64 `protobuf:"varint,9,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,10,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` // API version implies the encode of the key and value. ApiVersion kvrpcpb.APIVersion `protobuf:"varint,11,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` // cipher_iv is used to encrypt/decrypt sst CipherIv []byte `protobuf:"bytes,12,opt,name=cipher_iv,json=cipherIv,proto3" json:"cipher_iv,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SSTMeta) Reset() { *m = SSTMeta{} } func (m *SSTMeta) String() string { return proto.CompactTextString(m) } func (*SSTMeta) ProtoMessage() {} func (*SSTMeta) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{3} } func (m *SSTMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SSTMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SSTMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SSTMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_SSTMeta.Merge(dst, src) } func (m *SSTMeta) XXX_Size() int { return m.Size() } func (m *SSTMeta) XXX_DiscardUnknown() { xxx_messageInfo_SSTMeta.DiscardUnknown(m) } var xxx_messageInfo_SSTMeta proto.InternalMessageInfo func (m *SSTMeta) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *SSTMeta) GetRange() *Range { if m != nil { return m.Range } return nil } func (m *SSTMeta) GetCrc32() uint32 { if m != nil { return m.Crc32 } return 0 } func (m *SSTMeta) GetLength() uint64 { if m != nil { return m.Length } return 0 } func (m *SSTMeta) GetCfName() string { if m != nil { return m.CfName } return "" } func (m *SSTMeta) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *SSTMeta) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *SSTMeta) GetEndKeyExclusive() bool { if m != nil { return m.EndKeyExclusive } return false } func (m *SSTMeta) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *SSTMeta) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func (m *SSTMeta) GetApiVersion() kvrpcpb.APIVersion { if m != nil { return m.ApiVersion } return kvrpcpb.APIVersion_V1 } func (m *SSTMeta) GetCipherIv() []byte { if m != nil { return m.CipherIv } return nil } // A rewrite rule is applied on the *encoded* keys (the internal storage // representation). type RewriteRule struct { OldKeyPrefix []byte `protobuf:"bytes,1,opt,name=old_key_prefix,json=oldKeyPrefix,proto3" json:"old_key_prefix,omitempty"` NewKeyPrefix []byte `protobuf:"bytes,2,opt,name=new_key_prefix,json=newKeyPrefix,proto3" json:"new_key_prefix,omitempty"` NewTimestamp uint64 `protobuf:"varint,3,opt,name=new_timestamp,json=newTimestamp,proto3" json:"new_timestamp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RewriteRule) Reset() { *m = RewriteRule{} } func (m *RewriteRule) String() string { return proto.CompactTextString(m) } func (*RewriteRule) ProtoMessage() {} func (*RewriteRule) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{4} } func (m *RewriteRule) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RewriteRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RewriteRule.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RewriteRule) XXX_Merge(src proto.Message) { xxx_messageInfo_RewriteRule.Merge(dst, src) } func (m *RewriteRule) XXX_Size() int { return m.Size() } func (m *RewriteRule) XXX_DiscardUnknown() { xxx_messageInfo_RewriteRule.DiscardUnknown(m) } var xxx_messageInfo_RewriteRule proto.InternalMessageInfo func (m *RewriteRule) GetOldKeyPrefix() []byte { if m != nil { return m.OldKeyPrefix } return nil } func (m *RewriteRule) GetNewKeyPrefix() []byte { if m != nil { return m.NewKeyPrefix } return nil } func (m *RewriteRule) GetNewTimestamp() uint64 { if m != nil { return m.NewTimestamp } return 0 } type UploadRequest struct { // Types that are valid to be assigned to Chunk: // *UploadRequest_Meta // *UploadRequest_Data Chunk isUploadRequest_Chunk `protobuf_oneof:"chunk"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UploadRequest) Reset() { *m = UploadRequest{} } func (m *UploadRequest) String() string { return proto.CompactTextString(m) } func (*UploadRequest) ProtoMessage() {} func (*UploadRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{5} } func (m *UploadRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UploadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UploadRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UploadRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UploadRequest.Merge(dst, src) } func (m *UploadRequest) XXX_Size() int { return m.Size() } func (m *UploadRequest) XXX_DiscardUnknown() { xxx_messageInfo_UploadRequest.DiscardUnknown(m) } var xxx_messageInfo_UploadRequest proto.InternalMessageInfo type isUploadRequest_Chunk interface { isUploadRequest_Chunk() MarshalTo([]byte) (int, error) Size() int } type UploadRequest_Meta struct { Meta *SSTMeta `protobuf:"bytes,1,opt,name=meta,oneof"` } type UploadRequest_Data struct { Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"` } func (*UploadRequest_Meta) isUploadRequest_Chunk() {} func (*UploadRequest_Data) isUploadRequest_Chunk() {} func (m *UploadRequest) GetChunk() isUploadRequest_Chunk { if m != nil { return m.Chunk } return nil } func (m *UploadRequest) GetMeta() *SSTMeta { if x, ok := m.GetChunk().(*UploadRequest_Meta); ok { return x.Meta } return nil } func (m *UploadRequest) GetData() []byte { if x, ok := m.GetChunk().(*UploadRequest_Data); ok { return x.Data } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*UploadRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _UploadRequest_OneofMarshaler, _UploadRequest_OneofUnmarshaler, _UploadRequest_OneofSizer, []interface{}{ (*UploadRequest_Meta)(nil), (*UploadRequest_Data)(nil), } } func _UploadRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*UploadRequest) // chunk switch x := m.Chunk.(type) { case *UploadRequest_Meta: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Meta); err != nil { return err } case *UploadRequest_Data: _ = b.EncodeVarint(2<<3 | proto.WireBytes) _ = b.EncodeRawBytes(x.Data) case nil: default: return fmt.Errorf("UploadRequest.Chunk has unexpected type %T", x) } return nil } func _UploadRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*UploadRequest) switch tag { case 1: // chunk.meta if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(SSTMeta) err := b.DecodeMessage(msg) m.Chunk = &UploadRequest_Meta{msg} return true, err case 2: // chunk.data if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } x, err := b.DecodeRawBytes(true) m.Chunk = &UploadRequest_Data{x} return true, err default: return false, nil } } func _UploadRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*UploadRequest) // chunk switch x := m.Chunk.(type) { case *UploadRequest_Meta: s := proto.Size(x.Meta) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *UploadRequest_Data: n += 1 // tag and wire n += proto.SizeVarint(uint64(len(x.Data))) n += len(x.Data) case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type UploadResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UploadResponse) Reset() { *m = UploadResponse{} } func (m *UploadResponse) String() string { return proto.CompactTextString(m) } func (*UploadResponse) ProtoMessage() {} func (*UploadResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{6} } func (m *UploadResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UploadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UploadResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UploadResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UploadResponse.Merge(dst, src) } func (m *UploadResponse) XXX_Size() int { return m.Size() } func (m *UploadResponse) XXX_DiscardUnknown() { xxx_messageInfo_UploadResponse.DiscardUnknown(m) } var xxx_messageInfo_UploadResponse proto.InternalMessageInfo type IngestRequest struct { Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Sst *SSTMeta `protobuf:"bytes,2,opt,name=sst" json:"sst,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IngestRequest) Reset() { *m = IngestRequest{} } func (m *IngestRequest) String() string { return proto.CompactTextString(m) } func (*IngestRequest) ProtoMessage() {} func (*IngestRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{7} } func (m *IngestRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IngestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IngestRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IngestRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_IngestRequest.Merge(dst, src) } func (m *IngestRequest) XXX_Size() int { return m.Size() } func (m *IngestRequest) XXX_DiscardUnknown() { xxx_messageInfo_IngestRequest.DiscardUnknown(m) } var xxx_messageInfo_IngestRequest proto.InternalMessageInfo func (m *IngestRequest) GetContext() *kvrpcpb.Context { if m != nil { return m.Context } return nil } func (m *IngestRequest) GetSst() *SSTMeta { if m != nil { return m.Sst } return nil } type MultiIngestRequest struct { Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Ssts []*SSTMeta `protobuf:"bytes,2,rep,name=ssts" json:"ssts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MultiIngestRequest) Reset() { *m = MultiIngestRequest{} } func (m *MultiIngestRequest) String() string { return proto.CompactTextString(m) } func (*MultiIngestRequest) ProtoMessage() {} func (*MultiIngestRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{8} } func (m *MultiIngestRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MultiIngestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MultiIngestRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MultiIngestRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MultiIngestRequest.Merge(dst, src) } func (m *MultiIngestRequest) XXX_Size() int { return m.Size() } func (m *MultiIngestRequest) XXX_DiscardUnknown() { xxx_messageInfo_MultiIngestRequest.DiscardUnknown(m) } var xxx_messageInfo_MultiIngestRequest proto.InternalMessageInfo func (m *MultiIngestRequest) GetContext() *kvrpcpb.Context { if m != nil { return m.Context } return nil } func (m *MultiIngestRequest) GetSsts() []*SSTMeta { if m != nil { return m.Ssts } return nil } type IngestResponse struct { Error *errorpb.Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IngestResponse) Reset() { *m = IngestResponse{} } func (m *IngestResponse) String() string { return proto.CompactTextString(m) } func (*IngestResponse) ProtoMessage() {} func (*IngestResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{9} } func (m *IngestResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IngestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IngestResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IngestResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_IngestResponse.Merge(dst, src) } func (m *IngestResponse) XXX_Size() int { return m.Size() } func (m *IngestResponse) XXX_DiscardUnknown() { xxx_messageInfo_IngestResponse.DiscardUnknown(m) } var xxx_messageInfo_IngestResponse proto.InternalMessageInfo func (m *IngestResponse) GetError() *errorpb.Error { if m != nil { return m.Error } return nil } type CompactRequest struct { // Compact files in the range and above the output level. // Compact all files if the range is not specified. // Compact all files to the bottommost level if the output level is -1. Range *Range `protobuf:"bytes,1,opt,name=range" json:"range,omitempty"` OutputLevel int32 `protobuf:"varint,2,opt,name=output_level,json=outputLevel,proto3" json:"output_level,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactRequest) Reset() { *m = CompactRequest{} } func (m *CompactRequest) String() string { return proto.CompactTextString(m) } func (*CompactRequest) ProtoMessage() {} func (*CompactRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{10} } func (m *CompactRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactRequest.Merge(dst, src) } func (m *CompactRequest) XXX_Size() int { return m.Size() } func (m *CompactRequest) XXX_DiscardUnknown() { xxx_messageInfo_CompactRequest.DiscardUnknown(m) } var xxx_messageInfo_CompactRequest proto.InternalMessageInfo func (m *CompactRequest) GetRange() *Range { if m != nil { return m.Range } return nil } func (m *CompactRequest) GetOutputLevel() int32 { if m != nil { return m.OutputLevel } return 0 } type CompactResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactResponse) Reset() { *m = CompactResponse{} } func (m *CompactResponse) String() string { return proto.CompactTextString(m) } func (*CompactResponse) ProtoMessage() {} func (*CompactResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{11} } func (m *CompactResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactResponse.Merge(dst, src) } func (m *CompactResponse) XXX_Size() int { return m.Size() } func (m *CompactResponse) XXX_DiscardUnknown() { xxx_messageInfo_CompactResponse.DiscardUnknown(m) } var xxx_messageInfo_CompactResponse proto.InternalMessageInfo type DownloadRequest struct { // The SST meta used to identify the downloaded file. // Must be the same among all nodes in the same Raft group. // Note: the "crc32" and "cf_name" fields are ignored in this request, // and the "range" field represents the closed key range after rewrite // (as origin keys in encoded representation). Sst SSTMeta `protobuf:"bytes,2,opt,name=sst" json:"sst"` // The file name of the SST file. Name string `protobuf:"bytes,9,opt,name=name,proto3" json:"name,omitempty"` // Performs a key prefix rewrite after downloading the SST file. // All keys in the SST will be rewritten as: // // new_key = new_key_prefix + old_key[len(old_key_prefix)..] // // When used for TiDB, rewriting the prefix changes the table ID. Please // note that key-rewrite is applied on the origin keys in encoded // representation (the SST itself should still use data keys in encoded // representation). // // You need to ensure that the keys before and after rewriting are in the // same order, otherwise the RPC request will fail. RewriteRule RewriteRule `protobuf:"bytes,13,opt,name=rewrite_rule,json=rewriteRule" json:"rewrite_rule"` StorageBackend *brpb.StorageBackend `protobuf:"bytes,14,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` IsRawKv bool `protobuf:"varint,15,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` // cipher_info is used to decrypt sst when download sst CipherInfo *brpb.CipherInfo `protobuf:"bytes,16,opt,name=cipher_info,json=cipherInfo" json:"cipher_info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DownloadRequest) Reset() { *m = DownloadRequest{} } func (m *DownloadRequest) String() string { return proto.CompactTextString(m) } func (*DownloadRequest) ProtoMessage() {} func (*DownloadRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{12} } func (m *DownloadRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DownloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DownloadRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DownloadRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DownloadRequest.Merge(dst, src) } func (m *DownloadRequest) XXX_Size() int { return m.Size() } func (m *DownloadRequest) XXX_DiscardUnknown() { xxx_messageInfo_DownloadRequest.DiscardUnknown(m) } var xxx_messageInfo_DownloadRequest proto.InternalMessageInfo func (m *DownloadRequest) GetSst() SSTMeta { if m != nil { return m.Sst } return SSTMeta{} } func (m *DownloadRequest) GetName() string { if m != nil { return m.Name } return "" } func (m *DownloadRequest) GetRewriteRule() RewriteRule { if m != nil { return m.RewriteRule } return RewriteRule{} } func (m *DownloadRequest) GetStorageBackend() *brpb.StorageBackend { if m != nil { return m.StorageBackend } return nil } func (m *DownloadRequest) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } func (m *DownloadRequest) GetCipherInfo() *brpb.CipherInfo { if m != nil { return m.CipherInfo } return nil } // For now it is just used for distinguishing the error of the request with the error // of gRPC, add more concrete types if it is necessary later. type Error struct { Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{13} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetMessage() string { if m != nil { return m.Message } return "" } type DownloadResponse struct { // The actual key range (after rewrite) of the downloaded SST. The range is // inclusive in both ends. Range Range `protobuf:"bytes,1,opt,name=range" json:"range"` // Whether the SST is empty. An empty SST is prohibited in TiKV, do not // ingest if this field is true. // (Deprecated, should be replaced by checking `length == 0` in the future) IsEmpty bool `protobuf:"varint,2,opt,name=is_empty,json=isEmpty,proto3" json:"is_empty,omitempty"` Error *Error `protobuf:"bytes,3,opt,name=error" json:"error,omitempty"` // The CRC32 checksum of the rewritten SST file (implementation can return // zero, indicating the CRC32 was not calculated). Crc32 uint32 `protobuf:"varint,4,opt,name=crc32,proto3" json:"crc32,omitempty"` // The actual length of the rewritten SST file. Length uint64 `protobuf:"varint,5,opt,name=length,proto3" json:"length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DownloadResponse) Reset() { *m = DownloadResponse{} } func (m *DownloadResponse) String() string { return proto.CompactTextString(m) } func (*DownloadResponse) ProtoMessage() {} func (*DownloadResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{14} } func (m *DownloadResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DownloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DownloadResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DownloadResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DownloadResponse.Merge(dst, src) } func (m *DownloadResponse) XXX_Size() int { return m.Size() } func (m *DownloadResponse) XXX_DiscardUnknown() { xxx_messageInfo_DownloadResponse.DiscardUnknown(m) } var xxx_messageInfo_DownloadResponse proto.InternalMessageInfo func (m *DownloadResponse) GetRange() Range { if m != nil { return m.Range } return Range{} } func (m *DownloadResponse) GetIsEmpty() bool { if m != nil { return m.IsEmpty } return false } func (m *DownloadResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *DownloadResponse) GetCrc32() uint32 { if m != nil { return m.Crc32 } return 0 } func (m *DownloadResponse) GetLength() uint64 { if m != nil { return m.Length } return 0 } type SetDownloadSpeedLimitRequest struct { // The download speed limit (bytes/second). Set to 0 for unlimited speed. SpeedLimit uint64 `protobuf:"varint,1,opt,name=speed_limit,json=speedLimit,proto3" json:"speed_limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SetDownloadSpeedLimitRequest) Reset() { *m = SetDownloadSpeedLimitRequest{} } func (m *SetDownloadSpeedLimitRequest) String() string { return proto.CompactTextString(m) } func (*SetDownloadSpeedLimitRequest) ProtoMessage() {} func (*SetDownloadSpeedLimitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{15} } func (m *SetDownloadSpeedLimitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SetDownloadSpeedLimitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetDownloadSpeedLimitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SetDownloadSpeedLimitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SetDownloadSpeedLimitRequest.Merge(dst, src) } func (m *SetDownloadSpeedLimitRequest) XXX_Size() int { return m.Size() } func (m *SetDownloadSpeedLimitRequest) XXX_DiscardUnknown() { xxx_messageInfo_SetDownloadSpeedLimitRequest.DiscardUnknown(m) } var xxx_messageInfo_SetDownloadSpeedLimitRequest proto.InternalMessageInfo func (m *SetDownloadSpeedLimitRequest) GetSpeedLimit() uint64 { if m != nil { return m.SpeedLimit } return 0 } type SetDownloadSpeedLimitResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SetDownloadSpeedLimitResponse) Reset() { *m = SetDownloadSpeedLimitResponse{} } func (m *SetDownloadSpeedLimitResponse) String() string { return proto.CompactTextString(m) } func (*SetDownloadSpeedLimitResponse) ProtoMessage() {} func (*SetDownloadSpeedLimitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{16} } func (m *SetDownloadSpeedLimitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SetDownloadSpeedLimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SetDownloadSpeedLimitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SetDownloadSpeedLimitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SetDownloadSpeedLimitResponse.Merge(dst, src) } func (m *SetDownloadSpeedLimitResponse) XXX_Size() int { return m.Size() } func (m *SetDownloadSpeedLimitResponse) XXX_DiscardUnknown() { xxx_messageInfo_SetDownloadSpeedLimitResponse.DiscardUnknown(m) } var xxx_messageInfo_SetDownloadSpeedLimitResponse proto.InternalMessageInfo type Pair struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` Op Pair_OP `protobuf:"varint,3,opt,name=op,proto3,enum=import_sstpb.Pair_OP" json:"op,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Pair) Reset() { *m = Pair{} } func (m *Pair) String() string { return proto.CompactTextString(m) } func (*Pair) ProtoMessage() {} func (*Pair) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{17} } func (m *Pair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Pair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Pair) XXX_Merge(src proto.Message) { xxx_messageInfo_Pair.Merge(dst, src) } func (m *Pair) XXX_Size() int { return m.Size() } func (m *Pair) XXX_DiscardUnknown() { xxx_messageInfo_Pair.DiscardUnknown(m) } var xxx_messageInfo_Pair proto.InternalMessageInfo func (m *Pair) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *Pair) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *Pair) GetOp() Pair_OP { if m != nil { return m.Op } return Pair_Put } type WriteBatch struct { CommitTs uint64 `protobuf:"varint,1,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` Pairs []*Pair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteBatch) Reset() { *m = WriteBatch{} } func (m *WriteBatch) String() string { return proto.CompactTextString(m) } func (*WriteBatch) ProtoMessage() {} func (*WriteBatch) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{18} } func (m *WriteBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteBatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteBatch.Merge(dst, src) } func (m *WriteBatch) XXX_Size() int { return m.Size() } func (m *WriteBatch) XXX_DiscardUnknown() { xxx_messageInfo_WriteBatch.DiscardUnknown(m) } var xxx_messageInfo_WriteBatch proto.InternalMessageInfo func (m *WriteBatch) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *WriteBatch) GetPairs() []*Pair { if m != nil { return m.Pairs } return nil } type WriteRequest struct { // Types that are valid to be assigned to Chunk: // *WriteRequest_Meta // *WriteRequest_Batch Chunk isWriteRequest_Chunk `protobuf_oneof:"chunk"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteRequest) Reset() { *m = WriteRequest{} } func (m *WriteRequest) String() string { return proto.CompactTextString(m) } func (*WriteRequest) ProtoMessage() {} func (*WriteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{19} } func (m *WriteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteRequest.Merge(dst, src) } func (m *WriteRequest) XXX_Size() int { return m.Size() } func (m *WriteRequest) XXX_DiscardUnknown() { xxx_messageInfo_WriteRequest.DiscardUnknown(m) } var xxx_messageInfo_WriteRequest proto.InternalMessageInfo type isWriteRequest_Chunk interface { isWriteRequest_Chunk() MarshalTo([]byte) (int, error) Size() int } type WriteRequest_Meta struct { Meta *SSTMeta `protobuf:"bytes,1,opt,name=meta,oneof"` } type WriteRequest_Batch struct { Batch *WriteBatch `protobuf:"bytes,2,opt,name=batch,oneof"` } func (*WriteRequest_Meta) isWriteRequest_Chunk() {} func (*WriteRequest_Batch) isWriteRequest_Chunk() {} func (m *WriteRequest) GetChunk() isWriteRequest_Chunk { if m != nil { return m.Chunk } return nil } func (m *WriteRequest) GetMeta() *SSTMeta { if x, ok := m.GetChunk().(*WriteRequest_Meta); ok { return x.Meta } return nil } func (m *WriteRequest) GetBatch() *WriteBatch { if x, ok := m.GetChunk().(*WriteRequest_Batch); ok { return x.Batch } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*WriteRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _WriteRequest_OneofMarshaler, _WriteRequest_OneofUnmarshaler, _WriteRequest_OneofSizer, []interface{}{ (*WriteRequest_Meta)(nil), (*WriteRequest_Batch)(nil), } } func _WriteRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*WriteRequest) // chunk switch x := m.Chunk.(type) { case *WriteRequest_Meta: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Meta); err != nil { return err } case *WriteRequest_Batch: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Batch); err != nil { return err } case nil: default: return fmt.Errorf("WriteRequest.Chunk has unexpected type %T", x) } return nil } func _WriteRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*WriteRequest) switch tag { case 1: // chunk.meta if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(SSTMeta) err := b.DecodeMessage(msg) m.Chunk = &WriteRequest_Meta{msg} return true, err case 2: // chunk.batch if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(WriteBatch) err := b.DecodeMessage(msg) m.Chunk = &WriteRequest_Batch{msg} return true, err default: return false, nil } } func _WriteRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*WriteRequest) // chunk switch x := m.Chunk.(type) { case *WriteRequest_Meta: s := proto.Size(x.Meta) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *WriteRequest_Batch: s := proto.Size(x.Batch) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type WriteResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` Metas []*SSTMeta `protobuf:"bytes,2,rep,name=metas" json:"metas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteResponse) Reset() { *m = WriteResponse{} } func (m *WriteResponse) String() string { return proto.CompactTextString(m) } func (*WriteResponse) ProtoMessage() {} func (*WriteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{20} } func (m *WriteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteResponse.Merge(dst, src) } func (m *WriteResponse) XXX_Size() int { return m.Size() } func (m *WriteResponse) XXX_DiscardUnknown() { xxx_messageInfo_WriteResponse.DiscardUnknown(m) } var xxx_messageInfo_WriteResponse proto.InternalMessageInfo func (m *WriteResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *WriteResponse) GetMetas() []*SSTMeta { if m != nil { return m.Metas } return nil } type RawWriteBatch struct { Ttl uint64 `protobuf:"varint,1,opt,name=ttl,proto3" json:"ttl,omitempty"` Pairs []*Pair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawWriteBatch) Reset() { *m = RawWriteBatch{} } func (m *RawWriteBatch) String() string { return proto.CompactTextString(m) } func (*RawWriteBatch) ProtoMessage() {} func (*RawWriteBatch) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{21} } func (m *RawWriteBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawWriteBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawWriteBatch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawWriteBatch) XXX_Merge(src proto.Message) { xxx_messageInfo_RawWriteBatch.Merge(dst, src) } func (m *RawWriteBatch) XXX_Size() int { return m.Size() } func (m *RawWriteBatch) XXX_DiscardUnknown() { xxx_messageInfo_RawWriteBatch.DiscardUnknown(m) } var xxx_messageInfo_RawWriteBatch proto.InternalMessageInfo func (m *RawWriteBatch) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } func (m *RawWriteBatch) GetPairs() []*Pair { if m != nil { return m.Pairs } return nil } type RawWriteRequest struct { // Types that are valid to be assigned to Chunk: // *RawWriteRequest_Meta // *RawWriteRequest_Batch Chunk isRawWriteRequest_Chunk `protobuf_oneof:"chunk"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawWriteRequest) Reset() { *m = RawWriteRequest{} } func (m *RawWriteRequest) String() string { return proto.CompactTextString(m) } func (*RawWriteRequest) ProtoMessage() {} func (*RawWriteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{22} } func (m *RawWriteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawWriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawWriteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawWriteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawWriteRequest.Merge(dst, src) } func (m *RawWriteRequest) XXX_Size() int { return m.Size() } func (m *RawWriteRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawWriteRequest.DiscardUnknown(m) } var xxx_messageInfo_RawWriteRequest proto.InternalMessageInfo type isRawWriteRequest_Chunk interface { isRawWriteRequest_Chunk() MarshalTo([]byte) (int, error) Size() int } type RawWriteRequest_Meta struct { Meta *SSTMeta `protobuf:"bytes,1,opt,name=meta,oneof"` } type RawWriteRequest_Batch struct { Batch *RawWriteBatch `protobuf:"bytes,2,opt,name=batch,oneof"` } func (*RawWriteRequest_Meta) isRawWriteRequest_Chunk() {} func (*RawWriteRequest_Batch) isRawWriteRequest_Chunk() {} func (m *RawWriteRequest) GetChunk() isRawWriteRequest_Chunk { if m != nil { return m.Chunk } return nil } func (m *RawWriteRequest) GetMeta() *SSTMeta { if x, ok := m.GetChunk().(*RawWriteRequest_Meta); ok { return x.Meta } return nil } func (m *RawWriteRequest) GetBatch() *RawWriteBatch { if x, ok := m.GetChunk().(*RawWriteRequest_Batch); ok { return x.Batch } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*RawWriteRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _RawWriteRequest_OneofMarshaler, _RawWriteRequest_OneofUnmarshaler, _RawWriteRequest_OneofSizer, []interface{}{ (*RawWriteRequest_Meta)(nil), (*RawWriteRequest_Batch)(nil), } } func _RawWriteRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*RawWriteRequest) // chunk switch x := m.Chunk.(type) { case *RawWriteRequest_Meta: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Meta); err != nil { return err } case *RawWriteRequest_Batch: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Batch); err != nil { return err } case nil: default: return fmt.Errorf("RawWriteRequest.Chunk has unexpected type %T", x) } return nil } func _RawWriteRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*RawWriteRequest) switch tag { case 1: // chunk.meta if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(SSTMeta) err := b.DecodeMessage(msg) m.Chunk = &RawWriteRequest_Meta{msg} return true, err case 2: // chunk.batch if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(RawWriteBatch) err := b.DecodeMessage(msg) m.Chunk = &RawWriteRequest_Batch{msg} return true, err default: return false, nil } } func _RawWriteRequest_OneofSizer(msg proto.Message) (n int) { m := msg.(*RawWriteRequest) // chunk switch x := m.Chunk.(type) { case *RawWriteRequest_Meta: s := proto.Size(x.Meta) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *RawWriteRequest_Batch: s := proto.Size(x.Batch) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type RawWriteResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` Metas []*SSTMeta `protobuf:"bytes,2,rep,name=metas" json:"metas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawWriteResponse) Reset() { *m = RawWriteResponse{} } func (m *RawWriteResponse) String() string { return proto.CompactTextString(m) } func (*RawWriteResponse) ProtoMessage() {} func (*RawWriteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{23} } func (m *RawWriteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawWriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawWriteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawWriteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawWriteResponse.Merge(dst, src) } func (m *RawWriteResponse) XXX_Size() int { return m.Size() } func (m *RawWriteResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawWriteResponse.DiscardUnknown(m) } var xxx_messageInfo_RawWriteResponse proto.InternalMessageInfo func (m *RawWriteResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *RawWriteResponse) GetMetas() []*SSTMeta { if m != nil { return m.Metas } return nil } type DuplicateDetectRequest struct { Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // Return only the keys found by scanning, not their values. KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` // We only check the data whose timestamp is larger than `min_commit_ts`. `min_commit_ts` is exclueded. MinCommitTs uint64 `protobuf:"varint,5,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DuplicateDetectRequest) Reset() { *m = DuplicateDetectRequest{} } func (m *DuplicateDetectRequest) String() string { return proto.CompactTextString(m) } func (*DuplicateDetectRequest) ProtoMessage() {} func (*DuplicateDetectRequest) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{24} } func (m *DuplicateDetectRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DuplicateDetectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DuplicateDetectRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DuplicateDetectRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DuplicateDetectRequest.Merge(dst, src) } func (m *DuplicateDetectRequest) XXX_Size() int { return m.Size() } func (m *DuplicateDetectRequest) XXX_DiscardUnknown() { xxx_messageInfo_DuplicateDetectRequest.DiscardUnknown(m) } var xxx_messageInfo_DuplicateDetectRequest proto.InternalMessageInfo func (m *DuplicateDetectRequest) GetContext() *kvrpcpb.Context { if m != nil { return m.Context } return nil } func (m *DuplicateDetectRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *DuplicateDetectRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *DuplicateDetectRequest) GetKeyOnly() bool { if m != nil { return m.KeyOnly } return false } func (m *DuplicateDetectRequest) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } type KvPair struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KvPair) Reset() { *m = KvPair{} } func (m *KvPair) String() string { return proto.CompactTextString(m) } func (*KvPair) ProtoMessage() {} func (*KvPair) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{25} } func (m *KvPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KvPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KvPair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KvPair) XXX_Merge(src proto.Message) { xxx_messageInfo_KvPair.Merge(dst, src) } func (m *KvPair) XXX_Size() int { return m.Size() } func (m *KvPair) XXX_DiscardUnknown() { xxx_messageInfo_KvPair.DiscardUnknown(m) } var xxx_messageInfo_KvPair proto.InternalMessageInfo func (m *KvPair) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *KvPair) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *KvPair) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } type DuplicateDetectResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` KeyError *Error `protobuf:"bytes,2,opt,name=key_error,json=keyError" json:"key_error,omitempty"` // The these keys will be in asc order (but commit time is in desc order), // and the content is just like following: // [ // {key: "key1", value: "value11", commit_ts: 1005}, // {key: "key1", value: "value12", commit_ts: 1004}, // {key: "key1", value: "value13", commit_ts: 1001}, // {key: "key2", value: "value21", commit_ts: 1004}, // {key: "key2", value: "value22", commit_ts: 1002}, // ... // ] Pairs []*KvPair `protobuf:"bytes,3,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DuplicateDetectResponse) Reset() { *m = DuplicateDetectResponse{} } func (m *DuplicateDetectResponse) String() string { return proto.CompactTextString(m) } func (*DuplicateDetectResponse) ProtoMessage() {} func (*DuplicateDetectResponse) Descriptor() ([]byte, []int) { return fileDescriptor_import_sstpb_982e8d0b590c003a, []int{26} } func (m *DuplicateDetectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DuplicateDetectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DuplicateDetectResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DuplicateDetectResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DuplicateDetectResponse.Merge(dst, src) } func (m *DuplicateDetectResponse) XXX_Size() int { return m.Size() } func (m *DuplicateDetectResponse) XXX_DiscardUnknown() { xxx_messageInfo_DuplicateDetectResponse.DiscardUnknown(m) } var xxx_messageInfo_DuplicateDetectResponse proto.InternalMessageInfo func (m *DuplicateDetectResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *DuplicateDetectResponse) GetKeyError() *Error { if m != nil { return m.KeyError } return nil } func (m *DuplicateDetectResponse) GetPairs() []*KvPair { if m != nil { return m.Pairs } return nil } func init() { proto.RegisterType((*SwitchModeRequest)(nil), "import_sstpb.SwitchModeRequest") proto.RegisterType((*SwitchModeResponse)(nil), "import_sstpb.SwitchModeResponse") proto.RegisterType((*Range)(nil), "import_sstpb.Range") proto.RegisterType((*SSTMeta)(nil), "import_sstpb.SSTMeta") proto.RegisterType((*RewriteRule)(nil), "import_sstpb.RewriteRule") proto.RegisterType((*UploadRequest)(nil), "import_sstpb.UploadRequest") proto.RegisterType((*UploadResponse)(nil), "import_sstpb.UploadResponse") proto.RegisterType((*IngestRequest)(nil), "import_sstpb.IngestRequest") proto.RegisterType((*MultiIngestRequest)(nil), "import_sstpb.MultiIngestRequest") proto.RegisterType((*IngestResponse)(nil), "import_sstpb.IngestResponse") proto.RegisterType((*CompactRequest)(nil), "import_sstpb.CompactRequest") proto.RegisterType((*CompactResponse)(nil), "import_sstpb.CompactResponse") proto.RegisterType((*DownloadRequest)(nil), "import_sstpb.DownloadRequest") proto.RegisterType((*Error)(nil), "import_sstpb.Error") proto.RegisterType((*DownloadResponse)(nil), "import_sstpb.DownloadResponse") proto.RegisterType((*SetDownloadSpeedLimitRequest)(nil), "import_sstpb.SetDownloadSpeedLimitRequest") proto.RegisterType((*SetDownloadSpeedLimitResponse)(nil), "import_sstpb.SetDownloadSpeedLimitResponse") proto.RegisterType((*Pair)(nil), "import_sstpb.Pair") proto.RegisterType((*WriteBatch)(nil), "import_sstpb.WriteBatch") proto.RegisterType((*WriteRequest)(nil), "import_sstpb.WriteRequest") proto.RegisterType((*WriteResponse)(nil), "import_sstpb.WriteResponse") proto.RegisterType((*RawWriteBatch)(nil), "import_sstpb.RawWriteBatch") proto.RegisterType((*RawWriteRequest)(nil), "import_sstpb.RawWriteRequest") proto.RegisterType((*RawWriteResponse)(nil), "import_sstpb.RawWriteResponse") proto.RegisterType((*DuplicateDetectRequest)(nil), "import_sstpb.DuplicateDetectRequest") proto.RegisterType((*KvPair)(nil), "import_sstpb.KvPair") proto.RegisterType((*DuplicateDetectResponse)(nil), "import_sstpb.DuplicateDetectResponse") proto.RegisterEnum("import_sstpb.SwitchMode", SwitchMode_name, SwitchMode_value) proto.RegisterEnum("import_sstpb.Pair_OP", Pair_OP_name, Pair_OP_value) } // 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 // Client API for ImportSST service type ImportSSTClient interface { // Switch to normal/import mode. SwitchMode(ctx context.Context, in *SwitchModeRequest, opts ...grpc.CallOption) (*SwitchModeResponse, error) // Upload an SST file to a server. Upload(ctx context.Context, opts ...grpc.CallOption) (ImportSST_UploadClient, error) // Ingest an uploaded SST file to a region. Ingest(ctx context.Context, in *IngestRequest, opts ...grpc.CallOption) (*IngestResponse, error) // Compact the specific range for better performance. Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) SetDownloadSpeedLimit(ctx context.Context, in *SetDownloadSpeedLimitRequest, opts ...grpc.CallOption) (*SetDownloadSpeedLimitResponse, error) // Download an SST file from an external storage, and performs key-rewrite // after downloading. Download(ctx context.Context, in *DownloadRequest, opts ...grpc.CallOption) (*DownloadResponse, error) // Open a write stream to generate sst files Write(ctx context.Context, opts ...grpc.CallOption) (ImportSST_WriteClient, error) RawWrite(ctx context.Context, opts ...grpc.CallOption) (ImportSST_RawWriteClient, error) // Ingest Multiple files in one request MultiIngest(ctx context.Context, in *MultiIngestRequest, opts ...grpc.CallOption) (*IngestResponse, error) // Collect duplicate data from TiKV. DuplicateDetect(ctx context.Context, in *DuplicateDetectRequest, opts ...grpc.CallOption) (ImportSST_DuplicateDetectClient, error) } type importSSTClient struct { cc *grpc.ClientConn } func NewImportSSTClient(cc *grpc.ClientConn) ImportSSTClient { return &importSSTClient{cc} } func (c *importSSTClient) SwitchMode(ctx context.Context, in *SwitchModeRequest, opts ...grpc.CallOption) (*SwitchModeResponse, error) { out := new(SwitchModeResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/SwitchMode", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) Upload(ctx context.Context, opts ...grpc.CallOption) (ImportSST_UploadClient, error) { stream, err := c.cc.NewStream(ctx, &_ImportSST_serviceDesc.Streams[0], "/import_sstpb.ImportSST/Upload", opts...) if err != nil { return nil, err } x := &importSSTUploadClient{stream} return x, nil } type ImportSST_UploadClient interface { Send(*UploadRequest) error CloseAndRecv() (*UploadResponse, error) grpc.ClientStream } type importSSTUploadClient struct { grpc.ClientStream } func (x *importSSTUploadClient) Send(m *UploadRequest) error { return x.ClientStream.SendMsg(m) } func (x *importSSTUploadClient) CloseAndRecv() (*UploadResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(UploadResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *importSSTClient) Ingest(ctx context.Context, in *IngestRequest, opts ...grpc.CallOption) (*IngestResponse, error) { out := new(IngestResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/Ingest", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) { out := new(CompactResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/Compact", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) SetDownloadSpeedLimit(ctx context.Context, in *SetDownloadSpeedLimitRequest, opts ...grpc.CallOption) (*SetDownloadSpeedLimitResponse, error) { out := new(SetDownloadSpeedLimitResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/SetDownloadSpeedLimit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) Download(ctx context.Context, in *DownloadRequest, opts ...grpc.CallOption) (*DownloadResponse, error) { out := new(DownloadResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/Download", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) Write(ctx context.Context, opts ...grpc.CallOption) (ImportSST_WriteClient, error) { stream, err := c.cc.NewStream(ctx, &_ImportSST_serviceDesc.Streams[1], "/import_sstpb.ImportSST/Write", opts...) if err != nil { return nil, err } x := &importSSTWriteClient{stream} return x, nil } type ImportSST_WriteClient interface { Send(*WriteRequest) error CloseAndRecv() (*WriteResponse, error) grpc.ClientStream } type importSSTWriteClient struct { grpc.ClientStream } func (x *importSSTWriteClient) Send(m *WriteRequest) error { return x.ClientStream.SendMsg(m) } func (x *importSSTWriteClient) CloseAndRecv() (*WriteResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(WriteResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *importSSTClient) RawWrite(ctx context.Context, opts ...grpc.CallOption) (ImportSST_RawWriteClient, error) { stream, err := c.cc.NewStream(ctx, &_ImportSST_serviceDesc.Streams[2], "/import_sstpb.ImportSST/RawWrite", opts...) if err != nil { return nil, err } x := &importSSTRawWriteClient{stream} return x, nil } type ImportSST_RawWriteClient interface { Send(*RawWriteRequest) error CloseAndRecv() (*RawWriteResponse, error) grpc.ClientStream } type importSSTRawWriteClient struct { grpc.ClientStream } func (x *importSSTRawWriteClient) Send(m *RawWriteRequest) error { return x.ClientStream.SendMsg(m) } func (x *importSSTRawWriteClient) CloseAndRecv() (*RawWriteResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(RawWriteResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *importSSTClient) MultiIngest(ctx context.Context, in *MultiIngestRequest, opts ...grpc.CallOption) (*IngestResponse, error) { out := new(IngestResponse) err := c.cc.Invoke(ctx, "/import_sstpb.ImportSST/MultiIngest", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *importSSTClient) DuplicateDetect(ctx context.Context, in *DuplicateDetectRequest, opts ...grpc.CallOption) (ImportSST_DuplicateDetectClient, error) { stream, err := c.cc.NewStream(ctx, &_ImportSST_serviceDesc.Streams[3], "/import_sstpb.ImportSST/DuplicateDetect", opts...) if err != nil { return nil, err } x := &importSSTDuplicateDetectClient{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 ImportSST_DuplicateDetectClient interface { Recv() (*DuplicateDetectResponse, error) grpc.ClientStream } type importSSTDuplicateDetectClient struct { grpc.ClientStream } func (x *importSSTDuplicateDetectClient) Recv() (*DuplicateDetectResponse, error) { m := new(DuplicateDetectResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for ImportSST service type ImportSSTServer interface { // Switch to normal/import mode. SwitchMode(context.Context, *SwitchModeRequest) (*SwitchModeResponse, error) // Upload an SST file to a server. Upload(ImportSST_UploadServer) error // Ingest an uploaded SST file to a region. Ingest(context.Context, *IngestRequest) (*IngestResponse, error) // Compact the specific range for better performance. Compact(context.Context, *CompactRequest) (*CompactResponse, error) SetDownloadSpeedLimit(context.Context, *SetDownloadSpeedLimitRequest) (*SetDownloadSpeedLimitResponse, error) // Download an SST file from an external storage, and performs key-rewrite // after downloading. Download(context.Context, *DownloadRequest) (*DownloadResponse, error) // Open a write stream to generate sst files Write(ImportSST_WriteServer) error RawWrite(ImportSST_RawWriteServer) error // Ingest Multiple files in one request MultiIngest(context.Context, *MultiIngestRequest) (*IngestResponse, error) // Collect duplicate data from TiKV. DuplicateDetect(*DuplicateDetectRequest, ImportSST_DuplicateDetectServer) error } func RegisterImportSSTServer(s *grpc.Server, srv ImportSSTServer) { s.RegisterService(&_ImportSST_serviceDesc, srv) } func _ImportSST_SwitchMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SwitchModeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).SwitchMode(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/SwitchMode", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).SwitchMode(ctx, req.(*SwitchModeRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_Upload_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ImportSSTServer).Upload(&importSSTUploadServer{stream}) } type ImportSST_UploadServer interface { SendAndClose(*UploadResponse) error Recv() (*UploadRequest, error) grpc.ServerStream } type importSSTUploadServer struct { grpc.ServerStream } func (x *importSSTUploadServer) SendAndClose(m *UploadResponse) error { return x.ServerStream.SendMsg(m) } func (x *importSSTUploadServer) Recv() (*UploadRequest, error) { m := new(UploadRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _ImportSST_Ingest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(IngestRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).Ingest(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/Ingest", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).Ingest(ctx, req.(*IngestRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CompactRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).Compact(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/Compact", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).Compact(ctx, req.(*CompactRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_SetDownloadSpeedLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SetDownloadSpeedLimitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).SetDownloadSpeedLimit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/SetDownloadSpeedLimit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).SetDownloadSpeedLimit(ctx, req.(*SetDownloadSpeedLimitRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_Download_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DownloadRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).Download(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/Download", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).Download(ctx, req.(*DownloadRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_Write_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ImportSSTServer).Write(&importSSTWriteServer{stream}) } type ImportSST_WriteServer interface { SendAndClose(*WriteResponse) error Recv() (*WriteRequest, error) grpc.ServerStream } type importSSTWriteServer struct { grpc.ServerStream } func (x *importSSTWriteServer) SendAndClose(m *WriteResponse) error { return x.ServerStream.SendMsg(m) } func (x *importSSTWriteServer) Recv() (*WriteRequest, error) { m := new(WriteRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _ImportSST_RawWrite_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ImportSSTServer).RawWrite(&importSSTRawWriteServer{stream}) } type ImportSST_RawWriteServer interface { SendAndClose(*RawWriteResponse) error Recv() (*RawWriteRequest, error) grpc.ServerStream } type importSSTRawWriteServer struct { grpc.ServerStream } func (x *importSSTRawWriteServer) SendAndClose(m *RawWriteResponse) error { return x.ServerStream.SendMsg(m) } func (x *importSSTRawWriteServer) Recv() (*RawWriteRequest, error) { m := new(RawWriteRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _ImportSST_MultiIngest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MultiIngestRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImportSSTServer).MultiIngest(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/import_sstpb.ImportSST/MultiIngest", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImportSSTServer).MultiIngest(ctx, req.(*MultiIngestRequest)) } return interceptor(ctx, in, info, handler) } func _ImportSST_DuplicateDetect_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(DuplicateDetectRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(ImportSSTServer).DuplicateDetect(m, &importSSTDuplicateDetectServer{stream}) } type ImportSST_DuplicateDetectServer interface { Send(*DuplicateDetectResponse) error grpc.ServerStream } type importSSTDuplicateDetectServer struct { grpc.ServerStream } func (x *importSSTDuplicateDetectServer) Send(m *DuplicateDetectResponse) error { return x.ServerStream.SendMsg(m) } var _ImportSST_serviceDesc = grpc.ServiceDesc{ ServiceName: "import_sstpb.ImportSST", HandlerType: (*ImportSSTServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "SwitchMode", Handler: _ImportSST_SwitchMode_Handler, }, { MethodName: "Ingest", Handler: _ImportSST_Ingest_Handler, }, { MethodName: "Compact", Handler: _ImportSST_Compact_Handler, }, { MethodName: "SetDownloadSpeedLimit", Handler: _ImportSST_SetDownloadSpeedLimit_Handler, }, { MethodName: "Download", Handler: _ImportSST_Download_Handler, }, { MethodName: "MultiIngest", Handler: _ImportSST_MultiIngest_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "Upload", Handler: _ImportSST_Upload_Handler, ClientStreams: true, }, { StreamName: "Write", Handler: _ImportSST_Write_Handler, ClientStreams: true, }, { StreamName: "RawWrite", Handler: _ImportSST_RawWrite_Handler, ClientStreams: true, }, { StreamName: "DuplicateDetect", Handler: _ImportSST_DuplicateDetect_Handler, ServerStreams: true, }, }, Metadata: "import_sstpb.proto", } func (m *SwitchModeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SwitchModeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Mode != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Mode)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SwitchModeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SwitchModeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Range) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Range) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Start) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Start))) i += copy(dAtA[i:], m.Start) } if len(m.End) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.End))) i += copy(dAtA[i:], m.End) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SSTMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SSTMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Uuid) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.Range != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Range.Size())) n1, err := m.Range.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.Crc32 != 0 { dAtA[i] = 0x18 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Crc32)) } if m.Length != 0 { dAtA[i] = 0x20 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Length)) } if len(m.CfName) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.CfName))) i += copy(dAtA[i:], m.CfName) } if m.RegionId != 0 { dAtA[i] = 0x30 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.RegionId)) } if m.RegionEpoch != nil { dAtA[i] = 0x3a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.RegionEpoch.Size())) n2, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.EndKeyExclusive { dAtA[i] = 0x40 i++ if m.EndKeyExclusive { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.TotalKvs != 0 { dAtA[i] = 0x48 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x50 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.TotalBytes)) } if m.ApiVersion != 0 { dAtA[i] = 0x58 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.ApiVersion)) } if len(m.CipherIv) > 0 { dAtA[i] = 0x62 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.CipherIv))) i += copy(dAtA[i:], m.CipherIv) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RewriteRule) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RewriteRule) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.OldKeyPrefix) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.OldKeyPrefix))) i += copy(dAtA[i:], m.OldKeyPrefix) } if len(m.NewKeyPrefix) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.NewKeyPrefix))) i += copy(dAtA[i:], m.NewKeyPrefix) } if m.NewTimestamp != 0 { dAtA[i] = 0x18 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.NewTimestamp)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UploadRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UploadRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Chunk != nil { nn3, err := m.Chunk.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UploadRequest_Meta) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Meta != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Meta.Size())) n4, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } return i, nil } func (m *UploadRequest_Data) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Data != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } return i, nil } func (m *UploadResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UploadResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IngestRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IngestRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Context.Size())) n5, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.Sst != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Sst.Size())) n6, err := m.Sst.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MultiIngestRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MultiIngestRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Context.Size())) n7, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if len(m.Ssts) > 0 { for _, msg := range m.Ssts { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IngestResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IngestResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Error.Size())) n8, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Range != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Range.Size())) n9, err := m.Range.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.OutputLevel != 0 { dAtA[i] = 0x10 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.OutputLevel)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DownloadRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DownloadRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Sst.Size())) n10, err := m.Sst.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 if len(m.Name) > 0 { dAtA[i] = 0x4a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } dAtA[i] = 0x6a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.RewriteRule.Size())) n11, err := m.RewriteRule.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 if m.StorageBackend != nil { dAtA[i] = 0x72 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.StorageBackend.Size())) n12, err := m.StorageBackend.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.IsRawKv { dAtA[i] = 0x78 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.CipherInfo != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.CipherInfo.Size())) n13, err := m.CipherInfo.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Message) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DownloadResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DownloadResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Range.Size())) n14, err := m.Range.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 if m.IsEmpty { dAtA[i] = 0x10 i++ if m.IsEmpty { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.Error != nil { dAtA[i] = 0x1a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Error.Size())) n15, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.Crc32 != 0 { dAtA[i] = 0x20 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Crc32)) } if m.Length != 0 { dAtA[i] = 0x28 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Length)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SetDownloadSpeedLimitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SetDownloadSpeedLimitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.SpeedLimit != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.SpeedLimit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SetDownloadSpeedLimitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SetDownloadSpeedLimitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Pair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Pair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.Op != 0 { dAtA[i] = 0x18 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Op)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteBatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteBatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CommitTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.CommitTs)) } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Chunk != nil { nn16, err := m.Chunk.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn16 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteRequest_Meta) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Meta != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Meta.Size())) n17, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } return i, nil } func (m *WriteRequest_Batch) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Batch != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Batch.Size())) n18, err := m.Batch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } return i, nil } func (m *WriteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Error.Size())) n19, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if len(m.Metas) > 0 { for _, msg := range m.Metas { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawWriteBatch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawWriteBatch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Ttl != 0 { dAtA[i] = 0x8 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Ttl)) } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawWriteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawWriteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Chunk != nil { nn20, err := m.Chunk.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn20 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawWriteRequest_Meta) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Meta != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Meta.Size())) n21, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } return i, nil } func (m *RawWriteRequest_Batch) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Batch != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Batch.Size())) n22, err := m.Batch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } return i, nil } func (m *RawWriteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawWriteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Error.Size())) n23, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 } if len(m.Metas) > 0 { for _, msg := range m.Metas { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DuplicateDetectRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DuplicateDetectRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.Context.Size())) n24, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n24 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.KeyOnly { dAtA[i] = 0x20 i++ if m.KeyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.MinCommitTs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.MinCommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KvPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KvPair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.CommitTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DuplicateDetectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DuplicateDetectResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.RegionError.Size())) n25, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } if m.KeyError != nil { dAtA[i] = 0x12 i++ i = encodeVarintImportSstpb(dAtA, i, uint64(m.KeyError.Size())) n26, err := m.KeyError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x1a i++ i = encodeVarintImportSstpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintImportSstpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *SwitchModeRequest) Size() (n int) { var l int _ = l if m.Mode != 0 { n += 1 + sovImportSstpb(uint64(m.Mode)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SwitchModeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Range) Size() (n int) { var l int _ = l l = len(m.Start) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.End) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SSTMeta) Size() (n int) { var l int _ = l l = len(m.Uuid) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.Range != nil { l = m.Range.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.Crc32 != 0 { n += 1 + sovImportSstpb(uint64(m.Crc32)) } if m.Length != 0 { n += 1 + sovImportSstpb(uint64(m.Length)) } l = len(m.CfName) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovImportSstpb(uint64(m.RegionId)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.EndKeyExclusive { n += 2 } if m.TotalKvs != 0 { n += 1 + sovImportSstpb(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovImportSstpb(uint64(m.TotalBytes)) } if m.ApiVersion != 0 { n += 1 + sovImportSstpb(uint64(m.ApiVersion)) } l = len(m.CipherIv) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RewriteRule) Size() (n int) { var l int _ = l l = len(m.OldKeyPrefix) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.NewKeyPrefix) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.NewTimestamp != 0 { n += 1 + sovImportSstpb(uint64(m.NewTimestamp)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UploadRequest) Size() (n int) { var l int _ = l if m.Chunk != nil { n += m.Chunk.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UploadRequest_Meta) Size() (n int) { var l int _ = l if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *UploadRequest_Data) Size() (n int) { var l int _ = l if m.Data != nil { l = len(m.Data) n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *UploadResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IngestRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.Sst != nil { l = m.Sst.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MultiIngestRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if len(m.Ssts) > 0 { for _, e := range m.Ssts { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IngestResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactRequest) Size() (n int) { var l int _ = l if m.Range != nil { l = m.Range.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.OutputLevel != 0 { n += 1 + sovImportSstpb(uint64(m.OutputLevel)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DownloadRequest) Size() (n int) { var l int _ = l l = m.Sst.Size() n += 1 + l + sovImportSstpb(uint64(l)) l = len(m.Name) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = m.RewriteRule.Size() n += 1 + l + sovImportSstpb(uint64(l)) if m.StorageBackend != nil { l = m.StorageBackend.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.IsRawKv { n += 2 } if m.CipherInfo != nil { l = m.CipherInfo.Size() n += 2 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l l = len(m.Message) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DownloadResponse) Size() (n int) { var l int _ = l l = m.Range.Size() n += 1 + l + sovImportSstpb(uint64(l)) if m.IsEmpty { n += 2 } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.Crc32 != 0 { n += 1 + sovImportSstpb(uint64(m.Crc32)) } if m.Length != 0 { n += 1 + sovImportSstpb(uint64(m.Length)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SetDownloadSpeedLimitRequest) Size() (n int) { var l int _ = l if m.SpeedLimit != 0 { n += 1 + sovImportSstpb(uint64(m.SpeedLimit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SetDownloadSpeedLimitResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Pair) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.Op != 0 { n += 1 + sovImportSstpb(uint64(m.Op)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteBatch) Size() (n int) { var l int _ = l if m.CommitTs != 0 { n += 1 + sovImportSstpb(uint64(m.CommitTs)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteRequest) Size() (n int) { var l int _ = l if m.Chunk != nil { n += m.Chunk.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteRequest_Meta) Size() (n int) { var l int _ = l if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *WriteRequest_Batch) Size() (n int) { var l int _ = l if m.Batch != nil { l = m.Batch.Size() n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *WriteResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if len(m.Metas) > 0 { for _, e := range m.Metas { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawWriteBatch) Size() (n int) { var l int _ = l if m.Ttl != 0 { n += 1 + sovImportSstpb(uint64(m.Ttl)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawWriteRequest) Size() (n int) { var l int _ = l if m.Chunk != nil { n += m.Chunk.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawWriteRequest_Meta) Size() (n int) { var l int _ = l if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *RawWriteRequest_Batch) Size() (n int) { var l int _ = l if m.Batch != nil { l = m.Batch.Size() n += 1 + l + sovImportSstpb(uint64(l)) } return n } func (m *RawWriteResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if len(m.Metas) > 0 { for _, e := range m.Metas { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DuplicateDetectRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.KeyOnly { n += 2 } if m.MinCommitTs != 0 { n += 1 + sovImportSstpb(uint64(m.MinCommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KvPair) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovImportSstpb(uint64(l)) } if m.CommitTs != 0 { n += 1 + sovImportSstpb(uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DuplicateDetectResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if m.KeyError != nil { l = m.KeyError.Size() n += 1 + l + sovImportSstpb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovImportSstpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovImportSstpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozImportSstpb(x uint64) (n int) { return sovImportSstpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *SwitchModeRequest) 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 ErrIntOverflowImportSstpb } 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: SwitchModeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SwitchModeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) } m.Mode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Mode |= (SwitchMode(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *SwitchModeResponse) 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 ErrIntOverflowImportSstpb } 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: SwitchModeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SwitchModeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *Range) 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 ErrIntOverflowImportSstpb } 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: Range: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Start = append(m.Start[:0], dAtA[iNdEx:postIndex]...) if m.Start == nil { m.Start = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.End = append(m.End[:0], dAtA[iNdEx:postIndex]...) if m.End == nil { m.End = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *SSTMeta) 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 ErrIntOverflowImportSstpb } 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: SSTMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SSTMeta: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Range == nil { m.Range = &Range{} } if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc32", wireType) } m.Crc32 = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc32 |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } m.Length = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Length |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CfName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } 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 ErrInvalidLengthImportSstpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.CfName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndKeyExclusive", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.EndKeyExclusive = bool(v != 0) case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (kvrpcpb.APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) if m.CipherIv == nil { m.CipherIv = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *RewriteRule) 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 ErrIntOverflowImportSstpb } 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: RewriteRule: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RewriteRule: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OldKeyPrefix", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.OldKeyPrefix = append(m.OldKeyPrefix[:0], dAtA[iNdEx:postIndex]...) if m.OldKeyPrefix == nil { m.OldKeyPrefix = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NewKeyPrefix", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.NewKeyPrefix = append(m.NewKeyPrefix[:0], dAtA[iNdEx:postIndex]...) if m.NewKeyPrefix == nil { m.NewKeyPrefix = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NewTimestamp", wireType) } m.NewTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NewTimestamp |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *UploadRequest) 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 ErrIntOverflowImportSstpb } 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: UploadRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UploadRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &SSTMeta{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &UploadRequest_Meta{v} iNdEx = postIndex 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 ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } v := make([]byte, postIndex-iNdEx) copy(v, dAtA[iNdEx:postIndex]) m.Chunk = &UploadRequest_Data{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *UploadResponse) 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 ErrIntOverflowImportSstpb } 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: UploadResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UploadResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *IngestRequest) 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 ErrIntOverflowImportSstpb } 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: IngestRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IngestRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &kvrpcpb.Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Sst == nil { m.Sst = &SSTMeta{} } if err := m.Sst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *MultiIngestRequest) 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 ErrIntOverflowImportSstpb } 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: MultiIngestRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MultiIngestRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &kvrpcpb.Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ssts", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ssts = append(m.Ssts, &SSTMeta{}) if err := m.Ssts[len(m.Ssts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *IngestResponse) 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 ErrIntOverflowImportSstpb } 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: IngestResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IngestResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &errorpb.Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *CompactRequest) 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 ErrIntOverflowImportSstpb } 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: CompactRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Range == nil { m.Range = &Range{} } if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field OutputLevel", wireType) } m.OutputLevel = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.OutputLevel |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *CompactResponse) 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 ErrIntOverflowImportSstpb } 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: CompactResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *DownloadRequest) 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 ErrIntOverflowImportSstpb } 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: DownloadRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DownloadRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Sst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: 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 ErrIntOverflowImportSstpb } 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 ErrInvalidLengthImportSstpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RewriteRule", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.RewriteRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StorageBackend == nil { m.StorageBackend = &brpb.StorageBackend{} } if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 15: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CipherInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CipherInfo == nil { m.CipherInfo = &brpb.CipherInfo{} } if err := m.CipherInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *Error) 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 ErrIntOverflowImportSstpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } 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 ErrInvalidLengthImportSstpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *DownloadResponse) 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 ErrIntOverflowImportSstpb } 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: DownloadResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DownloadResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsEmpty", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsEmpty = bool(v != 0) case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Crc32", wireType) } m.Crc32 = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Crc32 |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } m.Length = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Length |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *SetDownloadSpeedLimitRequest) 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 ErrIntOverflowImportSstpb } 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: SetDownloadSpeedLimitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SetDownloadSpeedLimitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SpeedLimit", wireType) } m.SpeedLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SpeedLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *SetDownloadSpeedLimitResponse) 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 ErrIntOverflowImportSstpb } 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: SetDownloadSpeedLimitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SetDownloadSpeedLimitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *Pair) 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 ErrIntOverflowImportSstpb } 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: Pair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Pair: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType) } m.Op = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Op |= (Pair_OP(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *WriteBatch) 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 ErrIntOverflowImportSstpb } 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: WriteBatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteBatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &Pair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *WriteRequest) 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 ErrIntOverflowImportSstpb } 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: WriteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &SSTMeta{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &WriteRequest_Meta{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &WriteBatch{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &WriteRequest_Batch{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *WriteResponse) 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 ErrIntOverflowImportSstpb } 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: WriteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Metas = append(m.Metas, &SSTMeta{}) if err := m.Metas[len(m.Metas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *RawWriteBatch) 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 ErrIntOverflowImportSstpb } 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: RawWriteBatch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawWriteBatch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &Pair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *RawWriteRequest) 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 ErrIntOverflowImportSstpb } 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: RawWriteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawWriteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &SSTMeta{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &RawWriteRequest_Meta{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &RawWriteBatch{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Chunk = &RawWriteRequest_Batch{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *RawWriteResponse) 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 ErrIntOverflowImportSstpb } 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: RawWriteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawWriteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Metas = append(m.Metas, &SSTMeta{}) if err := m.Metas[len(m.Metas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *DuplicateDetectRequest) 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 ErrIntOverflowImportSstpb } 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: DuplicateDetectRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DuplicateDetectRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &kvrpcpb.Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.KeyOnly = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *KvPair) 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 ErrIntOverflowImportSstpb } 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: KvPair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KvPair: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 *DuplicateDetectResponse) 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 ErrIntOverflowImportSstpb } 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: DuplicateDetectResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DuplicateDetectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.KeyError == nil { m.KeyError = &Error{} } if err := m.KeyError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowImportSstpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthImportSstpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KvPair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthImportSstpb } 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 skipImportSstpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportSstpb } 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, ErrIntOverflowImportSstpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportSstpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthImportSstpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowImportSstpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipImportSstpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthImportSstpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowImportSstpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_import_sstpb_982e8d0b590c003a) } var fileDescriptor_import_sstpb_982e8d0b590c003a = []byte{ // 1524 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4b, 0x6f, 0x1c, 0xc5, 0x13, 0xf7, 0x78, 0xdf, 0xb5, 0xcf, 0x74, 0x9c, 0x64, 0xb2, 0x4e, 0x6c, 0x67, 0xfe, 0xce, 0x1f, 0xc7, 0x81, 0x4d, 0xb0, 0x51, 0xae, 0x51, 0xfc, 0x10, 0x31, 0x8e, 0x63, 0xd3, 0x6b, 0xe0, 0x80, 0xc4, 0x68, 0x3c, 0xdb, 0x5e, 0x0f, 0x3b, 0x2f, 0xa6, 0x7b, 0x76, 0xb3, 0x12, 0xe2, 0x73, 0x70, 0xe5, 0x86, 0xb8, 0x23, 0xc4, 0x99, 0x4b, 0x8e, 0x1c, 0x39, 0x21, 0x14, 0xbe, 0x08, 0xea, 0xc7, 0xec, 0x63, 0xb2, 0xb6, 0x89, 0x25, 0x4e, 0xdb, 0x5d, 0x55, 0x53, 0x55, 0x53, 0xf5, 0xab, 0xdf, 0xd4, 0x02, 0x72, 0xbc, 0x30, 0x88, 0x98, 0x49, 0x29, 0x0b, 0x4f, 0x5a, 0x61, 0x14, 0xb0, 0x00, 0x55, 0x26, 0x65, 0xcd, 0x8a, 0x47, 0x98, 0x95, 0xe8, 0x9a, 0x55, 0x12, 0x45, 0x41, 0x34, 0xbe, 0xf6, 0xfa, 0x51, 0x68, 0x8f, 0xae, 0x0b, 0xdd, 0xa0, 0x1b, 0x88, 0xe3, 0x23, 0x7e, 0x52, 0xd2, 0x7a, 0x14, 0x53, 0x26, 0x8e, 0x4a, 0x00, 0x27, 0x23, 0x0f, 0xc6, 0x33, 0xb8, 0xd6, 0x1e, 0x38, 0xcc, 0x3e, 0x3b, 0x08, 0x3a, 0x04, 0x93, 0x6f, 0x62, 0x42, 0x19, 0x7a, 0x1f, 0xb2, 0x5e, 0xd0, 0x21, 0xba, 0xb6, 0xa2, 0xad, 0xd5, 0x36, 0xf4, 0xd6, 0x54, 0x92, 0x13, 0xe6, 0xc2, 0xca, 0x58, 0x00, 0x34, 0xe9, 0x82, 0x86, 0x81, 0x4f, 0x89, 0xf1, 0x08, 0x72, 0xd8, 0xf2, 0xbb, 0x04, 0x2d, 0x40, 0x8e, 0x32, 0x2b, 0x62, 0xc2, 0x5b, 0x05, 0xcb, 0x0b, 0x6a, 0x40, 0x86, 0xf8, 0x1d, 0x7d, 0x5e, 0xc8, 0xf8, 0xd1, 0xf8, 0x21, 0x03, 0x85, 0x76, 0xfb, 0xf8, 0x80, 0x30, 0x0b, 0x21, 0xc8, 0xc6, 0xb1, 0xd3, 0x51, 0x8f, 0x88, 0x33, 0x7a, 0x00, 0xb9, 0x88, 0x3b, 0x14, 0xcf, 0x94, 0x37, 0xae, 0x4f, 0x67, 0x25, 0x62, 0x61, 0x69, 0xc1, 0x43, 0xda, 0x91, 0xbd, 0xb9, 0xa1, 0x67, 0x56, 0xb4, 0xb5, 0x2a, 0x96, 0x17, 0x74, 0x13, 0xf2, 0x2e, 0xf1, 0xbb, 0xec, 0x4c, 0xcf, 0xae, 0x68, 0x6b, 0x59, 0xac, 0x6e, 0xe8, 0x16, 0x14, 0xec, 0x53, 0xd3, 0xb7, 0x3c, 0xa2, 0xe7, 0x56, 0xb4, 0xb5, 0x12, 0xce, 0xdb, 0xa7, 0x2f, 0x2d, 0x8f, 0xa0, 0x45, 0x28, 0x45, 0xa4, 0xeb, 0x04, 0xbe, 0xe9, 0x74, 0xf4, 0xbc, 0x78, 0xa6, 0x28, 0x05, 0x7b, 0x1d, 0xf4, 0x04, 0x2a, 0x4a, 0x49, 0xc2, 0xc0, 0x3e, 0xd3, 0x0b, 0x2a, 0x2b, 0xd5, 0x2e, 0x2c, 0x74, 0xbb, 0x5c, 0x85, 0xcb, 0xd1, 0xf8, 0x82, 0xd6, 0xe1, 0x1a, 0xf1, 0x3b, 0x66, 0x8f, 0x0c, 0x4d, 0xf2, 0xca, 0x76, 0x63, 0xea, 0xf4, 0x89, 0x5e, 0x5c, 0xd1, 0xd6, 0x8a, 0xb8, 0x4e, 0xfc, 0xce, 0x3e, 0x19, 0xee, 0x26, 0x62, 0x9e, 0x00, 0x0b, 0x98, 0xe5, 0x9a, 0xbd, 0x3e, 0xd5, 0x4b, 0x32, 0x01, 0x21, 0xd8, 0xef, 0x53, 0xb4, 0x0c, 0x65, 0xa9, 0x3c, 0x19, 0x32, 0x42, 0x75, 0x10, 0x6a, 0x10, 0xa2, 0x2d, 0x2e, 0x41, 0x1f, 0x41, 0xd9, 0x0a, 0x1d, 0xb3, 0x4f, 0x22, 0xea, 0x04, 0xbe, 0x5e, 0x16, 0xcd, 0xbc, 0xde, 0x4a, 0x20, 0xf3, 0xec, 0x68, 0xef, 0x73, 0xa9, 0xc2, 0x60, 0x85, 0x8e, 0x3a, 0xf3, 0x98, 0xb6, 0x13, 0x9e, 0x91, 0xc8, 0x74, 0xfa, 0x7a, 0x45, 0xd4, 0xbf, 0x28, 0x05, 0x7b, 0x7d, 0xe3, 0x3b, 0x28, 0x63, 0x32, 0x88, 0x1c, 0x46, 0x70, 0xec, 0x12, 0xb4, 0x0a, 0xb5, 0xc0, 0x95, 0xef, 0x12, 0x46, 0xe4, 0xd4, 0x79, 0xa5, 0x1a, 0x56, 0x09, 0x5c, 0xfe, 0x22, 0x47, 0x42, 0xc6, 0xad, 0x7c, 0x32, 0x98, 0xb4, 0x92, 0x5d, 0xaf, 0xf8, 0x64, 0x30, 0xb6, 0xfa, 0x1f, 0x54, 0xb9, 0x15, 0x73, 0x3c, 0x42, 0x99, 0xe5, 0x85, 0xa2, 0x77, 0x59, 0x61, 0x74, 0x9c, 0xc8, 0x8c, 0x2f, 0xa1, 0xfa, 0x59, 0xe8, 0x06, 0x56, 0x27, 0x41, 0xea, 0x43, 0xc8, 0xf2, 0x82, 0x8b, 0xb8, 0xe5, 0x8d, 0x1b, 0x29, 0xa4, 0x4a, 0x34, 0x3d, 0x9f, 0xc3, 0xc2, 0x08, 0x2d, 0x40, 0xb6, 0x63, 0x31, 0x4b, 0x86, 0xe7, 0x52, 0x7e, 0xdb, 0x2a, 0x40, 0xce, 0x3e, 0x8b, 0xfd, 0x9e, 0xd1, 0x80, 0x5a, 0xe2, 0x5c, 0x61, 0xb8, 0x03, 0xd5, 0x3d, 0xbf, 0x4b, 0x28, 0x4b, 0xc2, 0xad, 0x43, 0xc1, 0x0e, 0x7c, 0x46, 0x5e, 0x31, 0x15, 0xb1, 0x31, 0x2a, 0xe7, 0xb6, 0x94, 0xe3, 0xc4, 0x00, 0xbd, 0x07, 0x19, 0x4a, 0x99, 0x42, 0xeb, 0xec, 0xcc, 0x30, 0xb7, 0x30, 0x7a, 0x80, 0x0e, 0x62, 0x97, 0x39, 0x57, 0x0f, 0xf5, 0x00, 0xb2, 0x94, 0x32, 0xaa, 0xcf, 0xaf, 0x64, 0xce, 0x8f, 0x25, 0x4c, 0x8c, 0x27, 0x50, 0x4b, 0xe2, 0xc8, 0x97, 0x44, 0xab, 0x90, 0x13, 0xa4, 0xa2, 0xc2, 0xd4, 0x5a, 0x09, 0xc5, 0xec, 0xf2, 0x5f, 0x2c, 0x95, 0xc6, 0x57, 0x50, 0xdb, 0x0e, 0xbc, 0xd0, 0xb2, 0x47, 0x09, 0x8e, 0xe6, 0x51, 0xbb, 0x74, 0x1e, 0xef, 0x41, 0x25, 0x88, 0x59, 0x18, 0x33, 0xd3, 0x25, 0x7d, 0xe2, 0x8a, 0x9a, 0xe4, 0x70, 0x59, 0xca, 0x5e, 0x70, 0x91, 0x71, 0x0d, 0xea, 0x23, 0xff, 0xaa, 0xfa, 0x3f, 0xcf, 0x43, 0x7d, 0x27, 0x18, 0xf8, 0x93, 0xfd, 0xfe, 0xe0, 0xf2, 0xa2, 0x6e, 0x65, 0x5f, 0xff, 0xb9, 0x3c, 0x27, 0x4a, 0xcb, 0x79, 0x44, 0xcc, 0x75, 0x49, 0xcc, 0xb5, 0x38, 0xa3, 0x2d, 0x3e, 0xb8, 0x02, 0xc3, 0x66, 0x14, 0xbb, 0x44, 0xaf, 0x0a, 0x5f, 0xb7, 0x53, 0xe9, 0x8f, 0x51, 0xae, 0xfc, 0x95, 0xa3, 0x09, 0xe0, 0x3f, 0x85, 0x3a, 0x65, 0x41, 0x64, 0x75, 0x89, 0x79, 0x62, 0xd9, 0x3d, 0xce, 0x64, 0x35, 0xe1, 0xe6, 0x66, 0x8b, 0xdf, 0xe3, 0xb0, 0xd5, 0x96, 0xea, 0x2d, 0xa9, 0xc5, 0x35, 0x3a, 0x75, 0x47, 0x4d, 0x28, 0x39, 0xd4, 0x8c, 0xac, 0x81, 0xd9, 0xeb, 0xeb, 0x75, 0x31, 0xfd, 0x05, 0x87, 0x62, 0x6b, 0xb0, 0xdf, 0x47, 0x9b, 0x50, 0x4e, 0x26, 0xd0, 0x3f, 0x0d, 0xf4, 0x86, 0x70, 0x8c, 0x12, 0xc7, 0xdb, 0x72, 0x16, 0xfd, 0xd3, 0x00, 0x83, 0x3d, 0x3a, 0x7f, 0x92, 0x2d, 0x16, 0x1b, 0x25, 0x9c, 0x89, 0x23, 0xd7, 0xb8, 0x07, 0x39, 0xd1, 0x3a, 0xa4, 0x43, 0xc1, 0x23, 0x94, 0x5a, 0xaa, 0x47, 0x25, 0x9c, 0x5c, 0x8d, 0x5f, 0x34, 0x68, 0x8c, 0x4b, 0xab, 0x80, 0xf0, 0xe8, 0xf2, 0x86, 0xaa, 0x5a, 0xa8, 0xb6, 0xde, 0x86, 0xa2, 0x43, 0x4d, 0xe2, 0x85, 0x6c, 0x28, 0x3a, 0x22, 0xde, 0x61, 0x97, 0x5f, 0x39, 0x38, 0x24, 0xa8, 0x32, 0xb3, 0x7c, 0x4d, 0x22, 0x6b, 0x4c, 0xd6, 0xd9, 0xd9, 0x64, 0x9d, 0x9b, 0x24, 0x6b, 0xe3, 0x29, 0xdc, 0x69, 0x13, 0x96, 0xe4, 0xde, 0x0e, 0x09, 0xe9, 0xbc, 0x70, 0x3c, 0x67, 0x84, 0xca, 0x65, 0x28, 0x53, 0x2e, 0x34, 0x5d, 0x2e, 0x15, 0xaf, 0x92, 0xc5, 0x40, 0x47, 0x76, 0xc6, 0x32, 0xdc, 0x3d, 0xc7, 0x81, 0x82, 0x5d, 0x08, 0xd9, 0x23, 0xcb, 0x89, 0xf8, 0x17, 0xaa, 0x47, 0x86, 0x8a, 0xd1, 0xf8, 0x91, 0x67, 0xda, 0xb7, 0xdc, 0x98, 0x28, 0xfe, 0x92, 0x17, 0x74, 0x1f, 0xe6, 0x03, 0xc9, 0x56, 0xb5, 0x34, 0x22, 0xb9, 0x9f, 0xd6, 0xe1, 0x11, 0x9e, 0x0f, 0x42, 0xe3, 0x36, 0xcc, 0x1f, 0x1e, 0xa1, 0x02, 0x64, 0x8e, 0x62, 0xd6, 0x98, 0x43, 0x00, 0xf9, 0x1d, 0xe2, 0x12, 0x46, 0x1a, 0x9a, 0xd1, 0x06, 0xf8, 0x82, 0x43, 0x6b, 0xcb, 0x62, 0xf6, 0x99, 0x20, 0xe0, 0xc0, 0xf3, 0x1c, 0x66, 0x32, 0xaa, 0xf2, 0x2f, 0x4a, 0xc1, 0x31, 0x45, 0x6b, 0x90, 0x0b, 0x2d, 0x27, 0x4a, 0x46, 0x1d, 0xbd, 0x1d, 0x0f, 0x4b, 0x03, 0xa3, 0x0f, 0x15, 0xe1, 0xf4, 0x4a, 0x4c, 0xf9, 0x18, 0x72, 0x27, 0x3c, 0x19, 0x35, 0x68, 0xa9, 0x0d, 0x60, 0x9c, 0xec, 0xf3, 0x39, 0x2c, 0x0d, 0xc7, 0x2c, 0xda, 0x85, 0xaa, 0x8a, 0xab, 0x60, 0xf5, 0x60, 0x9a, 0x5f, 0x2e, 0x82, 0xc2, 0x43, 0xc8, 0xf1, 0xf0, 0x97, 0x10, 0x99, 0xb4, 0x31, 0xf6, 0xa1, 0x8a, 0xad, 0xc1, 0x44, 0xe1, 0x1a, 0x90, 0x61, 0xcc, 0x55, 0x25, 0xe3, 0xc7, 0x77, 0xa8, 0xd6, 0xb7, 0x50, 0x4f, 0x9c, 0x5d, 0xa9, 0x60, 0x9b, 0xd3, 0x05, 0x5b, 0x4c, 0xcf, 0xce, 0xe0, 0xc2, 0x9a, 0x7d, 0x0d, 0x8d, 0x71, 0xf4, 0xff, 0xb8, 0x6c, 0xbf, 0x6a, 0x70, 0x73, 0x27, 0x0e, 0x5d, 0xc7, 0xb6, 0x18, 0xd9, 0x21, 0x8c, 0xd8, 0x57, 0xfa, 0xe4, 0x2c, 0x42, 0x49, 0x2c, 0x72, 0xfc, 0xb3, 0xae, 0xe6, 0xa1, 0x28, 0x04, 0xfb, 0x64, 0xc8, 0x37, 0x2a, 0xb5, 0xe3, 0x88, 0xb9, 0xa8, 0xe0, 0xbc, 0xdc, 0x6c, 0x38, 0x63, 0xf0, 0x35, 0x20, 0xf0, 0xdd, 0xa1, 0x18, 0xf7, 0x22, 0x2e, 0xf4, 0xc8, 0xf0, 0xd0, 0x77, 0x87, 0xc8, 0x80, 0xaa, 0xe7, 0xf8, 0xe6, 0x18, 0xfa, 0x72, 0xee, 0xcb, 0x9e, 0xe3, 0x6f, 0x2b, 0xf4, 0x1b, 0x07, 0x90, 0xdf, 0xef, 0xbf, 0xd3, 0x70, 0x4e, 0x0d, 0x53, 0x66, 0x7a, 0x98, 0x8c, 0x9f, 0x34, 0xb8, 0xf5, 0x56, 0x29, 0x54, 0xf9, 0x3f, 0x1c, 0xaf, 0x77, 0x17, 0x7c, 0x1c, 0x93, 0xcd, 0x4e, 0xb4, 0xe1, 0x31, 0x94, 0xc4, 0x56, 0x27, 0xec, 0xe7, 0xcf, 0xef, 0x1a, 0x2f, 0x81, 0x7c, 0x62, 0x3d, 0xc1, 0x67, 0x46, 0x34, 0x6e, 0x61, 0xda, 0x5a, 0xbe, 0xaa, 0x42, 0xe8, 0xfa, 0x2a, 0xc0, 0x78, 0xcb, 0xe6, 0xf4, 0xf1, 0x32, 0x88, 0x3c, 0xcb, 0x95, 0x54, 0xb2, 0x27, 0x9e, 0x6b, 0x68, 0x1b, 0xbf, 0xe5, 0xa1, 0x24, 0x2f, 0xed, 0xf6, 0x31, 0xfa, 0x74, 0xea, 0x99, 0xe5, 0x73, 0xf7, 0x78, 0xd9, 0xff, 0xe6, 0xca, 0xf9, 0x06, 0x8a, 0x1b, 0xe7, 0xd0, 0xc7, 0x90, 0x97, 0x4b, 0x12, 0x4a, 0x61, 0x7c, 0x6a, 0x2f, 0x6b, 0xde, 0x99, 0xad, 0x4c, 0xdc, 0xac, 0x69, 0x68, 0x17, 0xf2, 0x72, 0x11, 0x49, 0x3b, 0x9a, 0x5a, 0x83, 0xd2, 0x8e, 0xa6, 0x77, 0x17, 0x63, 0x0e, 0x3d, 0x87, 0x82, 0xda, 0x1b, 0x50, 0xca, 0x74, 0x7a, 0x5d, 0x69, 0xde, 0x3d, 0x47, 0x3b, 0xf2, 0x14, 0xc1, 0x8d, 0x99, 0x1f, 0x06, 0xb4, 0x9e, 0x2a, 0xcb, 0x05, 0x9f, 0x9f, 0xe6, 0xc3, 0x7f, 0x65, 0x3b, 0x8a, 0xb9, 0x0f, 0xc5, 0x44, 0x8f, 0x52, 0x09, 0xa6, 0x36, 0x9f, 0xe6, 0xd2, 0x79, 0xea, 0x91, 0xb3, 0x1d, 0xc8, 0x09, 0x0a, 0x41, 0xcd, 0x19, 0x74, 0x9d, 0xb8, 0x59, 0x9c, 0xa9, 0x9b, 0xe8, 0xcb, 0x01, 0x14, 0x13, 0x2e, 0x4a, 0xa7, 0x94, 0x62, 0xc8, 0x74, 0x4a, 0x69, 0x0a, 0x13, 0xee, 0x0e, 0xa1, 0x3c, 0xb1, 0xdc, 0xa2, 0x14, 0xc4, 0xde, 0xde, 0x7b, 0x2f, 0x6d, 0xf8, 0x09, 0xd4, 0x53, 0x33, 0x8b, 0x56, 0x53, 0xa5, 0x99, 0xc9, 0x6e, 0xcd, 0xfb, 0x97, 0x58, 0x25, 0x11, 0x1e, 0x6b, 0x5b, 0xff, 0xff, 0xe3, 0xc7, 0xa2, 0xf6, 0xfa, 0xcd, 0x92, 0xf6, 0xfb, 0x9b, 0x25, 0xed, 0xaf, 0x37, 0x4b, 0xda, 0xf7, 0x7f, 0x2f, 0xcd, 0x41, 0x23, 0x88, 0xba, 0x2d, 0xe6, 0xf4, 0xfa, 0xad, 0x5e, 0x5f, 0xfc, 0x79, 0x3e, 0xc9, 0x8b, 0x9f, 0xcd, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x13, 0xf6, 0x26, 0xdc, 0xc6, 0x0f, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/kvrpcpb/000077500000000000000000000000001421456440000165355ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/kvrpcpb/kvrpcpb.pb.go000066400000000000000000031302771421456440000211500ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: kvrpcpb.proto package kvrpcpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" deadlock "github.com/pingcap/kvproto/pkg/deadlock" errorpb "github.com/pingcap/kvproto/pkg/errorpb" metapb "github.com/pingcap/kvproto/pkg/metapb" tracepb "github.com/pingcap/kvproto/pkg/tracepb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // The API version the server and the client is using. // See more details in https://github.com/tikv/rfcs/blob/master/text/0069-api-v2.md. type APIVersion int32 const ( // Mainly for TxnKV and not safe to use RawKV along with TxnKV. // // V1 server only accepts V1 requests. Except that the V1 raw requests with TTL // will be rejected. APIVersion_V1 APIVersion = 0 // Only RawKV is available, and then 8 bytes representing the unix timestamp in // seconds for expiring time will be append to the value of all RawKV kv pairs. // // ------------------------------------------------------------ // | User value | Expire Ts | // ------------------------------------------------------------ // | 0x12 0x34 0x56 | 0x00 0x00 0x00 0x00 0x00 0x00 0xff 0xff | // ------------------------------------------------------------ // // V1TTL server only accepts V1 raw requests. // V1 client should not use `V1TTL` in request. V1 client should always send `V1`. APIVersion_V1TTL APIVersion = 1 // TxnKV keys start with `x{keyspace id}`, `m`, or `t`. // // RawKV keys must be in `default` CF and all start with `r{keyspace id}` prefix, // where the keyspace id is in varint format (little endian), whose bytes expect // the last one always sets the most significant bit to 1. // // The last byte in the raw value must be a meta flag. For example: // // -------------------------------------- // | User value | Meta flags | // -------------------------------------- // | 0x12 0x34 0x56 | 0x00 (0b00000000) | // -------------------------------------- // // As shown in the example below, the least significant bit of the meta flag // indicates whether the value contains 8 bytes expire ts at the very left to the // meta flags. // // -------------------------------------------------------------------------------- // | User value | Expire Ts | Meta flags | // -------------------------------------------------------------------------------- // | 0x12 0x34 0x56 | 0x00 0x00 0x00 0x00 0x00 0x00 0xff 0xff | 0x01 (0b00000001) | // -------------------------------------------------------------------------------- // // V2 server accpets V2 requests and V1 txn requests that statrts with TiDB key // prefix (`m` and `t`). APIVersion_V2 APIVersion = 2 ) var APIVersion_name = map[int32]string{ 0: "V1", 1: "V1TTL", 2: "V2", } var APIVersion_value = map[string]int32{ "V1": 0, "V1TTL": 1, "V2": 2, } func (x APIVersion) String() string { return proto.EnumName(APIVersion_name, int32(x)) } func (APIVersion) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{0} } type CommandPri int32 const ( CommandPri_Normal CommandPri = 0 CommandPri_Low CommandPri = 1 CommandPri_High CommandPri = 2 ) var CommandPri_name = map[int32]string{ 0: "Normal", 1: "Low", 2: "High", } var CommandPri_value = map[string]int32{ "Normal": 0, "Low": 1, "High": 2, } func (x CommandPri) String() string { return proto.EnumName(CommandPri_name, int32(x)) } func (CommandPri) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{1} } type IsolationLevel int32 const ( IsolationLevel_SI IsolationLevel = 0 IsolationLevel_RC IsolationLevel = 1 IsolationLevel_RCCheckTS IsolationLevel = 2 ) var IsolationLevel_name = map[int32]string{ 0: "SI", 1: "RC", 2: "RCCheckTS", } var IsolationLevel_value = map[string]int32{ "SI": 0, "RC": 1, "RCCheckTS": 2, } func (x IsolationLevel) String() string { return proto.EnumName(IsolationLevel_name, int32(x)) } func (IsolationLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{2} } // Operation allowed info during each TiKV storage threshold. type DiskFullOpt int32 const ( DiskFullOpt_NotAllowedOnFull DiskFullOpt = 0 DiskFullOpt_AllowedOnAlmostFull DiskFullOpt = 1 DiskFullOpt_AllowedOnAlreadyFull DiskFullOpt = 2 ) var DiskFullOpt_name = map[int32]string{ 0: "NotAllowedOnFull", 1: "AllowedOnAlmostFull", 2: "AllowedOnAlreadyFull", } var DiskFullOpt_value = map[string]int32{ "NotAllowedOnFull": 0, "AllowedOnAlmostFull": 1, "AllowedOnAlreadyFull": 2, } func (x DiskFullOpt) String() string { return proto.EnumName(DiskFullOpt_name, int32(x)) } func (DiskFullOpt) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{3} } type Op int32 const ( Op_Put Op = 0 Op_Del Op = 1 Op_Lock Op = 2 Op_Rollback Op = 3 // insert operation has a constraint that key should not exist before. Op_Insert Op = 4 Op_PessimisticLock Op = 5 Op_CheckNotExists Op = 6 ) var Op_name = map[int32]string{ 0: "Put", 1: "Del", 2: "Lock", 3: "Rollback", 4: "Insert", 5: "PessimisticLock", 6: "CheckNotExists", } var Op_value = map[string]int32{ "Put": 0, "Del": 1, "Lock": 2, "Rollback": 3, "Insert": 4, "PessimisticLock": 5, "CheckNotExists": 6, } func (x Op) String() string { return proto.EnumName(Op_name, int32(x)) } func (Op) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{4} } type Assertion int32 const ( Assertion_None Assertion = 0 Assertion_Exist Assertion = 1 Assertion_NotExist Assertion = 2 ) var Assertion_name = map[int32]string{ 0: "None", 1: "Exist", 2: "NotExist", } var Assertion_value = map[string]int32{ "None": 0, "Exist": 1, "NotExist": 2, } func (x Assertion) String() string { return proto.EnumName(Assertion_name, int32(x)) } func (Assertion) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{5} } type AssertionLevel int32 const ( // No assertion. AssertionLevel_Off AssertionLevel = 0 // Assertion is enabled, but not enforced when it might affect performance. AssertionLevel_Fast AssertionLevel = 1 // Assertion is enabled and enforced. AssertionLevel_Strict AssertionLevel = 2 ) var AssertionLevel_name = map[int32]string{ 0: "Off", 1: "Fast", 2: "Strict", } var AssertionLevel_value = map[string]int32{ "Off": 0, "Fast": 1, "Strict": 2, } func (x AssertionLevel) String() string { return proto.EnumName(AssertionLevel_name, int32(x)) } func (AssertionLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{6} } type Action int32 const ( Action_NoAction Action = 0 Action_TTLExpireRollback Action = 1 Action_LockNotExistRollback Action = 2 Action_MinCommitTSPushed Action = 3 Action_TTLExpirePessimisticRollback Action = 4 Action_LockNotExistDoNothing Action = 5 ) var Action_name = map[int32]string{ 0: "NoAction", 1: "TTLExpireRollback", 2: "LockNotExistRollback", 3: "MinCommitTSPushed", 4: "TTLExpirePessimisticRollback", 5: "LockNotExistDoNothing", } var Action_value = map[string]int32{ "NoAction": 0, "TTLExpireRollback": 1, "LockNotExistRollback": 2, "MinCommitTSPushed": 3, "TTLExpirePessimisticRollback": 4, "LockNotExistDoNothing": 5, } func (x Action) String() string { return proto.EnumName(Action_name, int32(x)) } func (Action) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{7} } type ExtraOp int32 const ( ExtraOp_Noop ExtraOp = 0 // ReadOldValue represents to output the previous value for delete/update operations. ExtraOp_ReadOldValue ExtraOp = 1 ) var ExtraOp_name = map[int32]string{ 0: "Noop", 1: "ReadOldValue", } var ExtraOp_value = map[string]int32{ "Noop": 0, "ReadOldValue": 1, } func (x ExtraOp) String() string { return proto.EnumName(ExtraOp_name, int32(x)) } func (ExtraOp) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{8} } type ChecksumAlgorithm int32 const ( ChecksumAlgorithm_Crc64_Xor ChecksumAlgorithm = 0 ) var ChecksumAlgorithm_name = map[int32]string{ 0: "Crc64_Xor", } var ChecksumAlgorithm_value = map[string]int32{ "Crc64_Xor": 0, } func (x ChecksumAlgorithm) String() string { return proto.EnumName(ChecksumAlgorithm_name, int32(x)) } func (ChecksumAlgorithm) EnumDescriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{9} } // A transactional get command. Lookup a value for `key` in the transaction with // starting timestamp = `version`. type GetRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{0} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRequest.Merge(dst, 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 func (m *GetRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *GetRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *GetRequest) GetVersion() uint64 { if m != nil { return m.Version } return 0 } type GetResponse struct { // A region error indicates that the request was sent to the wrong TiKV node // (or other, similar errors). RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` // A value could not be retrieved due to the state of the database for the requested key. Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // A successful result. Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` // True if the key does not exist in the database. NotFound bool `protobuf:"varint,4,opt,name=not_found,json=notFound,proto3" json:"not_found,omitempty"` // Time and scan details when processing the request. ExecDetailsV2 *ExecDetailsV2 `protobuf:"bytes,6,opt,name=exec_details_v2,json=execDetailsV2" json:"exec_details_v2,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{1} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetResponse.Merge(dst, 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 func (m *GetResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *GetResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *GetResponse) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *GetResponse) GetNotFound() bool { if m != nil { return m.NotFound } return false } func (m *GetResponse) GetExecDetailsV2() *ExecDetailsV2 { if m != nil { return m.ExecDetailsV2 } return nil } // Scan fetches values for a range of keys; it is part of the transaction with // starting timestamp = `version`. type ScanRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` // The maximum number of results to return. Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` Version uint64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` // Return only the keys found by scanning, not their values. KeyOnly bool `protobuf:"varint,5,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` // For compatibility, when scanning forward, the range to scan is [start_key, end_key), where start_key < end_key; // and when scanning backward, it scans [end_key, start_key) in descending order, where end_key < start_key. EndKey []byte `protobuf:"bytes,7,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // If sample_step > 0, skips 'sample_step - 1' number of keys after each returned key. // locks are not checked. SampleStep uint32 `protobuf:"varint,8,opt,name=sample_step,json=sampleStep,proto3" json:"sample_step,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanRequest) Reset() { *m = ScanRequest{} } func (m *ScanRequest) String() string { return proto.CompactTextString(m) } func (*ScanRequest) ProtoMessage() {} func (*ScanRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{2} } func (m *ScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanRequest.Merge(dst, src) } func (m *ScanRequest) XXX_Size() int { return m.Size() } func (m *ScanRequest) XXX_DiscardUnknown() { xxx_messageInfo_ScanRequest.DiscardUnknown(m) } var xxx_messageInfo_ScanRequest proto.InternalMessageInfo func (m *ScanRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *ScanRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *ScanRequest) GetLimit() uint32 { if m != nil { return m.Limit } return 0 } func (m *ScanRequest) GetVersion() uint64 { if m != nil { return m.Version } return 0 } func (m *ScanRequest) GetKeyOnly() bool { if m != nil { return m.KeyOnly } return false } func (m *ScanRequest) GetReverse() bool { if m != nil { return m.Reverse } return false } func (m *ScanRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *ScanRequest) GetSampleStep() uint32 { if m != nil { return m.SampleStep } return 0 } type ScanResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` // Each KvPair may contain a key error. Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` // This KeyError exists when some key is locked but we cannot check locks of all keys. // In this case, `pairs` should be empty and the client should redo scanning all the keys // after resolving the lock. Error *KeyError `protobuf:"bytes,3,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanResponse) Reset() { *m = ScanResponse{} } func (m *ScanResponse) String() string { return proto.CompactTextString(m) } func (*ScanResponse) ProtoMessage() {} func (*ScanResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{3} } func (m *ScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanResponse.Merge(dst, src) } func (m *ScanResponse) XXX_Size() int { return m.Size() } func (m *ScanResponse) XXX_DiscardUnknown() { xxx_messageInfo_ScanResponse.DiscardUnknown(m) } var xxx_messageInfo_ScanResponse proto.InternalMessageInfo func (m *ScanResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *ScanResponse) GetPairs() []*KvPair { if m != nil { return m.Pairs } return nil } func (m *ScanResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } // A prewrite is the first phase of writing to TiKV. It contains all data to be written in a transaction. // TiKV will write the data in a preliminary state. Data cannot be read until it has been committed. // The client should only commit a transaction once all prewrites succeed. type PrewriteRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // The data to be written to the database. Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"` // The client picks one key to be primary (unrelated to the primary key concept in SQL). This // key's lock is the source of truth for the state of a transaction. All other locks due to a // transaction will point to the primary lock. PrimaryLock []byte `protobuf:"bytes,3,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` // Identifies the transaction being written. StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` LockTtl uint64 `protobuf:"varint,5,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` // TiKV can skip some checks, used for speeding up data migration. SkipConstraintCheck bool `protobuf:"varint,6,opt,name=skip_constraint_check,json=skipConstraintCheck,proto3" json:"skip_constraint_check,omitempty"` // For pessimistic transaction, some mutations don't need to be locked, for example, non-unique index key. IsPessimisticLock []bool `protobuf:"varint,7,rep,packed,name=is_pessimistic_lock,json=isPessimisticLock" json:"is_pessimistic_lock,omitempty"` // How many keys this transaction involves in this region. TxnSize uint64 `protobuf:"varint,8,opt,name=txn_size,json=txnSize,proto3" json:"txn_size,omitempty"` // For pessimistic transactions only; used to check if a conflict lock is already committed. ForUpdateTs uint64 `protobuf:"varint,9,opt,name=for_update_ts,json=forUpdateTs,proto3" json:"for_update_ts,omitempty"` // If min_commit_ts > 0, this is a large transaction request, the final commit_ts // will be inferred from `min_commit_ts`. MinCommitTs uint64 `protobuf:"varint,10,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` // When async commit is enabled, `secondaries` should be set as the key list of all secondary // locks if the request prewrites the primary lock. UseAsyncCommit bool `protobuf:"varint,11,opt,name=use_async_commit,json=useAsyncCommit,proto3" json:"use_async_commit,omitempty"` Secondaries [][]byte `protobuf:"bytes,12,rep,name=secondaries" json:"secondaries,omitempty"` // When the transaction involves only one region, it's possible to commit the transaction // directly with 1PC protocol. TryOnePc bool `protobuf:"varint,13,opt,name=try_one_pc,json=tryOnePc,proto3" json:"try_one_pc,omitempty"` // The max commit ts is reserved for limiting the commit ts of 1PC or async commit, which can be used to avoid // inconsistency with schema change. MaxCommitTs uint64 `protobuf:"varint,14,opt,name=max_commit_ts,json=maxCommitTs,proto3" json:"max_commit_ts,omitempty"` // The level of assertion to use on this prewrte request. AssertionLevel AssertionLevel `protobuf:"varint,15,opt,name=assertion_level,json=assertionLevel,proto3,enum=kvrpcpb.AssertionLevel" json:"assertion_level,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrewriteRequest) Reset() { *m = PrewriteRequest{} } func (m *PrewriteRequest) String() string { return proto.CompactTextString(m) } func (*PrewriteRequest) ProtoMessage() {} func (*PrewriteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{4} } func (m *PrewriteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrewriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrewriteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrewriteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PrewriteRequest.Merge(dst, src) } func (m *PrewriteRequest) XXX_Size() int { return m.Size() } func (m *PrewriteRequest) XXX_DiscardUnknown() { xxx_messageInfo_PrewriteRequest.DiscardUnknown(m) } var xxx_messageInfo_PrewriteRequest proto.InternalMessageInfo func (m *PrewriteRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *PrewriteRequest) GetMutations() []*Mutation { if m != nil { return m.Mutations } return nil } func (m *PrewriteRequest) GetPrimaryLock() []byte { if m != nil { return m.PrimaryLock } return nil } func (m *PrewriteRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *PrewriteRequest) GetLockTtl() uint64 { if m != nil { return m.LockTtl } return 0 } func (m *PrewriteRequest) GetSkipConstraintCheck() bool { if m != nil { return m.SkipConstraintCheck } return false } func (m *PrewriteRequest) GetIsPessimisticLock() []bool { if m != nil { return m.IsPessimisticLock } return nil } func (m *PrewriteRequest) GetTxnSize() uint64 { if m != nil { return m.TxnSize } return 0 } func (m *PrewriteRequest) GetForUpdateTs() uint64 { if m != nil { return m.ForUpdateTs } return 0 } func (m *PrewriteRequest) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } func (m *PrewriteRequest) GetUseAsyncCommit() bool { if m != nil { return m.UseAsyncCommit } return false } func (m *PrewriteRequest) GetSecondaries() [][]byte { if m != nil { return m.Secondaries } return nil } func (m *PrewriteRequest) GetTryOnePc() bool { if m != nil { return m.TryOnePc } return false } func (m *PrewriteRequest) GetMaxCommitTs() uint64 { if m != nil { return m.MaxCommitTs } return 0 } func (m *PrewriteRequest) GetAssertionLevel() AssertionLevel { if m != nil { return m.AssertionLevel } return AssertionLevel_Off } type PrewriteResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Errors []*KeyError `protobuf:"bytes,2,rep,name=errors" json:"errors,omitempty"` // 0 if the min_commit_ts is not ready or any other reason that async // commit cannot proceed. The client can then fallback to normal way to // continue committing the transaction if prewrite are all finished. MinCommitTs uint64 `protobuf:"varint,3,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` // When the transaction is successfully committed with 1PC protocol, this field will be set to // the commit ts of the transaction. Otherwise, if TiKV failed to commit it with 1PC or the // transaction is not 1PC, the value will be 0. OnePcCommitTs uint64 `protobuf:"varint,4,opt,name=one_pc_commit_ts,json=onePcCommitTs,proto3" json:"one_pc_commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrewriteResponse) Reset() { *m = PrewriteResponse{} } func (m *PrewriteResponse) String() string { return proto.CompactTextString(m) } func (*PrewriteResponse) ProtoMessage() {} func (*PrewriteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{5} } func (m *PrewriteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrewriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrewriteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrewriteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PrewriteResponse.Merge(dst, src) } func (m *PrewriteResponse) XXX_Size() int { return m.Size() } func (m *PrewriteResponse) XXX_DiscardUnknown() { xxx_messageInfo_PrewriteResponse.DiscardUnknown(m) } var xxx_messageInfo_PrewriteResponse proto.InternalMessageInfo func (m *PrewriteResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *PrewriteResponse) GetErrors() []*KeyError { if m != nil { return m.Errors } return nil } func (m *PrewriteResponse) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } func (m *PrewriteResponse) GetOnePcCommitTs() uint64 { if m != nil { return m.OnePcCommitTs } return 0 } // Lock a set of keys to prepare to write to them. type PessimisticLockRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // In this case every `Op` of the mutations must be `PessimisticLock`. Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"` PrimaryLock []byte `protobuf:"bytes,3,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` LockTtl uint64 `protobuf:"varint,5,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` // Each locking command in a pessimistic transaction has its own timestamp. If locking fails, then // the corresponding SQL statement can be retried with a later timestamp, TiDB does not need to // retry the whole transaction. The name comes from the `SELECT ... FOR UPDATE` SQL statement which // is a locking read. Each `SELECT ... FOR UPDATE` in a transaction will be assigned its own // timestamp. ForUpdateTs uint64 `protobuf:"varint,6,opt,name=for_update_ts,json=forUpdateTs,proto3" json:"for_update_ts,omitempty"` // If the request is the first lock request, we don't need to detect deadlock. IsFirstLock bool `protobuf:"varint,7,opt,name=is_first_lock,json=isFirstLock,proto3" json:"is_first_lock,omitempty"` // Time to wait for lock released in milliseconds when encountering locks. // 0 means using default timeout in TiKV. Negative means no wait. WaitTimeout int64 `protobuf:"varint,8,opt,name=wait_timeout,json=waitTimeout,proto3" json:"wait_timeout,omitempty"` // If it is true, TiKV will acquire the pessimistic lock regardless of write conflict // and return the latest value. It's only supported for single mutation. Force bool `protobuf:"varint,9,opt,name=force,proto3" json:"force,omitempty"` // Deprecated: Do not use. // If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for // later read in the same transaction. // When 'force' is set to true, this field is ignored. ReturnValues bool `protobuf:"varint,10,opt,name=return_values,json=returnValues,proto3" json:"return_values,omitempty"` // If min_commit_ts > 0, this is large transaction proto, the final commit_ts // would be infered from min_commit_ts. MinCommitTs uint64 `protobuf:"varint,11,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` // If set to true, it means TiKV need to check if the key exists, and return the result in // the `not_founds` feild in the response. This works no matter if `return_values` is set. If // `return_values` is set, it simply makes no difference; otherwise, the `value` field of the // repsonse will be empty while the `not_founds` field still indicates the keys' existence. CheckExistence bool `protobuf:"varint,12,opt,name=check_existence,json=checkExistence,proto3" json:"check_existence,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PessimisticLockRequest) Reset() { *m = PessimisticLockRequest{} } func (m *PessimisticLockRequest) String() string { return proto.CompactTextString(m) } func (*PessimisticLockRequest) ProtoMessage() {} func (*PessimisticLockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{6} } func (m *PessimisticLockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PessimisticLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PessimisticLockRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PessimisticLockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PessimisticLockRequest.Merge(dst, src) } func (m *PessimisticLockRequest) XXX_Size() int { return m.Size() } func (m *PessimisticLockRequest) XXX_DiscardUnknown() { xxx_messageInfo_PessimisticLockRequest.DiscardUnknown(m) } var xxx_messageInfo_PessimisticLockRequest proto.InternalMessageInfo func (m *PessimisticLockRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *PessimisticLockRequest) GetMutations() []*Mutation { if m != nil { return m.Mutations } return nil } func (m *PessimisticLockRequest) GetPrimaryLock() []byte { if m != nil { return m.PrimaryLock } return nil } func (m *PessimisticLockRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *PessimisticLockRequest) GetLockTtl() uint64 { if m != nil { return m.LockTtl } return 0 } func (m *PessimisticLockRequest) GetForUpdateTs() uint64 { if m != nil { return m.ForUpdateTs } return 0 } func (m *PessimisticLockRequest) GetIsFirstLock() bool { if m != nil { return m.IsFirstLock } return false } func (m *PessimisticLockRequest) GetWaitTimeout() int64 { if m != nil { return m.WaitTimeout } return 0 } // Deprecated: Do not use. func (m *PessimisticLockRequest) GetForce() bool { if m != nil { return m.Force } return false } func (m *PessimisticLockRequest) GetReturnValues() bool { if m != nil { return m.ReturnValues } return false } func (m *PessimisticLockRequest) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } func (m *PessimisticLockRequest) GetCheckExistence() bool { if m != nil { return m.CheckExistence } return false } type PessimisticLockResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Errors []*KeyError `protobuf:"bytes,2,rep,name=errors" json:"errors,omitempty"` // It carries the latest value and its commit ts if force in PessimisticLockRequest is true. CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` // Deprecated: Do not use. Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"` // Deprecated: Do not use. // The values is set if 'return_values' is true in the request and no error. // If 'force' is true, this field is not used. Values [][]byte `protobuf:"bytes,5,rep,name=values" json:"values,omitempty"` // Indicates whether the values at the same index is correspond to an existing key. // In legacy TiKV, this field is not used even 'force' is false. In that case, an empty value indicates // two possible situations: (1) the key does not exist. (2) the key exists but the value is empty. NotFounds []bool `protobuf:"varint,6,rep,packed,name=not_founds,json=notFounds" json:"not_founds,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PessimisticLockResponse) Reset() { *m = PessimisticLockResponse{} } func (m *PessimisticLockResponse) String() string { return proto.CompactTextString(m) } func (*PessimisticLockResponse) ProtoMessage() {} func (*PessimisticLockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{7} } func (m *PessimisticLockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PessimisticLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PessimisticLockResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PessimisticLockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PessimisticLockResponse.Merge(dst, src) } func (m *PessimisticLockResponse) XXX_Size() int { return m.Size() } func (m *PessimisticLockResponse) XXX_DiscardUnknown() { xxx_messageInfo_PessimisticLockResponse.DiscardUnknown(m) } var xxx_messageInfo_PessimisticLockResponse proto.InternalMessageInfo func (m *PessimisticLockResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *PessimisticLockResponse) GetErrors() []*KeyError { if m != nil { return m.Errors } return nil } // Deprecated: Do not use. func (m *PessimisticLockResponse) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } // Deprecated: Do not use. func (m *PessimisticLockResponse) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *PessimisticLockResponse) GetValues() [][]byte { if m != nil { return m.Values } return nil } func (m *PessimisticLockResponse) GetNotFounds() []bool { if m != nil { return m.NotFounds } return nil } // Unlock keys locked using `PessimisticLockRequest`. type PessimisticRollbackRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` ForUpdateTs uint64 `protobuf:"varint,3,opt,name=for_update_ts,json=forUpdateTs,proto3" json:"for_update_ts,omitempty"` Keys [][]byte `protobuf:"bytes,4,rep,name=keys" json:"keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PessimisticRollbackRequest) Reset() { *m = PessimisticRollbackRequest{} } func (m *PessimisticRollbackRequest) String() string { return proto.CompactTextString(m) } func (*PessimisticRollbackRequest) ProtoMessage() {} func (*PessimisticRollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{8} } func (m *PessimisticRollbackRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PessimisticRollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PessimisticRollbackRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PessimisticRollbackRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PessimisticRollbackRequest.Merge(dst, src) } func (m *PessimisticRollbackRequest) XXX_Size() int { return m.Size() } func (m *PessimisticRollbackRequest) XXX_DiscardUnknown() { xxx_messageInfo_PessimisticRollbackRequest.DiscardUnknown(m) } var xxx_messageInfo_PessimisticRollbackRequest proto.InternalMessageInfo func (m *PessimisticRollbackRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *PessimisticRollbackRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *PessimisticRollbackRequest) GetForUpdateTs() uint64 { if m != nil { return m.ForUpdateTs } return 0 } func (m *PessimisticRollbackRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } type PessimisticRollbackResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Errors []*KeyError `protobuf:"bytes,2,rep,name=errors" json:"errors,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PessimisticRollbackResponse) Reset() { *m = PessimisticRollbackResponse{} } func (m *PessimisticRollbackResponse) String() string { return proto.CompactTextString(m) } func (*PessimisticRollbackResponse) ProtoMessage() {} func (*PessimisticRollbackResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{9} } func (m *PessimisticRollbackResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PessimisticRollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PessimisticRollbackResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PessimisticRollbackResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PessimisticRollbackResponse.Merge(dst, src) } func (m *PessimisticRollbackResponse) XXX_Size() int { return m.Size() } func (m *PessimisticRollbackResponse) XXX_DiscardUnknown() { xxx_messageInfo_PessimisticRollbackResponse.DiscardUnknown(m) } var xxx_messageInfo_PessimisticRollbackResponse proto.InternalMessageInfo func (m *PessimisticRollbackResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *PessimisticRollbackResponse) GetErrors() []*KeyError { if m != nil { return m.Errors } return nil } // Used to update the lock_ttl of a psessimistic and/or large transaction to prevent it from been killed. type TxnHeartBeatRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // The key of the lock to update. PrimaryLock []byte `protobuf:"bytes,2,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` // Start timestamp of the large transaction. StartVersion uint64 `protobuf:"varint,3,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // The new TTL the sender would like. AdviseLockTtl uint64 `protobuf:"varint,4,opt,name=advise_lock_ttl,json=adviseLockTtl,proto3" json:"advise_lock_ttl,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnHeartBeatRequest) Reset() { *m = TxnHeartBeatRequest{} } func (m *TxnHeartBeatRequest) String() string { return proto.CompactTextString(m) } func (*TxnHeartBeatRequest) ProtoMessage() {} func (*TxnHeartBeatRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{10} } func (m *TxnHeartBeatRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnHeartBeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnHeartBeatRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnHeartBeatRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnHeartBeatRequest.Merge(dst, src) } func (m *TxnHeartBeatRequest) XXX_Size() int { return m.Size() } func (m *TxnHeartBeatRequest) XXX_DiscardUnknown() { xxx_messageInfo_TxnHeartBeatRequest.DiscardUnknown(m) } var xxx_messageInfo_TxnHeartBeatRequest proto.InternalMessageInfo func (m *TxnHeartBeatRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *TxnHeartBeatRequest) GetPrimaryLock() []byte { if m != nil { return m.PrimaryLock } return nil } func (m *TxnHeartBeatRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *TxnHeartBeatRequest) GetAdviseLockTtl() uint64 { if m != nil { return m.AdviseLockTtl } return 0 } type TxnHeartBeatResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // The TTL actually set on the requested lock. LockTtl uint64 `protobuf:"varint,3,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnHeartBeatResponse) Reset() { *m = TxnHeartBeatResponse{} } func (m *TxnHeartBeatResponse) String() string { return proto.CompactTextString(m) } func (*TxnHeartBeatResponse) ProtoMessage() {} func (*TxnHeartBeatResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{11} } func (m *TxnHeartBeatResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnHeartBeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnHeartBeatResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnHeartBeatResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnHeartBeatResponse.Merge(dst, src) } func (m *TxnHeartBeatResponse) XXX_Size() int { return m.Size() } func (m *TxnHeartBeatResponse) XXX_DiscardUnknown() { xxx_messageInfo_TxnHeartBeatResponse.DiscardUnknown(m) } var xxx_messageInfo_TxnHeartBeatResponse proto.InternalMessageInfo func (m *TxnHeartBeatResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *TxnHeartBeatResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *TxnHeartBeatResponse) GetLockTtl() uint64 { if m != nil { return m.LockTtl } return 0 } // CheckTxnStatusRequest checks the status of a transaction. // If the transaction is rollbacked/committed, return that result. // If the TTL of the transaction is exhausted, abort that transaction and inform the caller. // Otherwise, returns the TTL information for the transaction. // CheckTxnStatusRequest may also push forward the minCommitTS of a large transaction. type CheckTxnStatusRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // Primary key and lock ts together to locate the primary lock of a transaction. PrimaryKey []byte `protobuf:"bytes,2,opt,name=primary_key,json=primaryKey,proto3" json:"primary_key,omitempty"` // Starting timestamp of the transaction being checked. LockTs uint64 `protobuf:"varint,3,opt,name=lock_ts,json=lockTs,proto3" json:"lock_ts,omitempty"` // The start timestamp of the transaction which this request is part of. CallerStartTs uint64 `protobuf:"varint,4,opt,name=caller_start_ts,json=callerStartTs,proto3" json:"caller_start_ts,omitempty"` // The client must specify the current time to TiKV using this timestamp. It is used to check TTL // timeouts. It may be inaccurate. CurrentTs uint64 `protobuf:"varint,5,opt,name=current_ts,json=currentTs,proto3" json:"current_ts,omitempty"` // If true, then TiKV will leave a rollback tombstone in the write CF for `primary_key`, even if // that key is not locked. RollbackIfNotExist bool `protobuf:"varint,6,opt,name=rollback_if_not_exist,json=rollbackIfNotExist,proto3" json:"rollback_if_not_exist,omitempty"` // This field is set to true only if the transaction is known to fall back from async commit. // Then, CheckTxnStatus treats the transaction as non-async-commit even if the use_async_commit // field in the primary lock is true. ForceSyncCommit bool `protobuf:"varint,7,opt,name=force_sync_commit,json=forceSyncCommit,proto3" json:"force_sync_commit,omitempty"` // If the check request is used to resolve or decide the transaction status for a input pessimistic // lock, the transaction status could not be decided if the primary lock is pessimistic too and // it's still uncertain. ResolvingPessimisticLock bool `protobuf:"varint,8,opt,name=resolving_pessimistic_lock,json=resolvingPessimisticLock,proto3" json:"resolving_pessimistic_lock,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckTxnStatusRequest) Reset() { *m = CheckTxnStatusRequest{} } func (m *CheckTxnStatusRequest) String() string { return proto.CompactTextString(m) } func (*CheckTxnStatusRequest) ProtoMessage() {} func (*CheckTxnStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{12} } func (m *CheckTxnStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckTxnStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckTxnStatusRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckTxnStatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckTxnStatusRequest.Merge(dst, src) } func (m *CheckTxnStatusRequest) XXX_Size() int { return m.Size() } func (m *CheckTxnStatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckTxnStatusRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckTxnStatusRequest proto.InternalMessageInfo func (m *CheckTxnStatusRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *CheckTxnStatusRequest) GetPrimaryKey() []byte { if m != nil { return m.PrimaryKey } return nil } func (m *CheckTxnStatusRequest) GetLockTs() uint64 { if m != nil { return m.LockTs } return 0 } func (m *CheckTxnStatusRequest) GetCallerStartTs() uint64 { if m != nil { return m.CallerStartTs } return 0 } func (m *CheckTxnStatusRequest) GetCurrentTs() uint64 { if m != nil { return m.CurrentTs } return 0 } func (m *CheckTxnStatusRequest) GetRollbackIfNotExist() bool { if m != nil { return m.RollbackIfNotExist } return false } func (m *CheckTxnStatusRequest) GetForceSyncCommit() bool { if m != nil { return m.ForceSyncCommit } return false } func (m *CheckTxnStatusRequest) GetResolvingPessimisticLock() bool { if m != nil { return m.ResolvingPessimisticLock } return false } type CheckTxnStatusResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // Three kinds of transaction status: // locked: lock_ttl > 0 // committed: commit_version > 0 // rollbacked: lock_ttl = 0 && commit_version = 0 LockTtl uint64 `protobuf:"varint,3,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` CommitVersion uint64 `protobuf:"varint,4,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` // The action performed by TiKV (and why if the action is to rollback). Action Action `protobuf:"varint,5,opt,name=action,proto3,enum=kvrpcpb.Action" json:"action,omitempty"` LockInfo *LockInfo `protobuf:"bytes,6,opt,name=lock_info,json=lockInfo" json:"lock_info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckTxnStatusResponse) Reset() { *m = CheckTxnStatusResponse{} } func (m *CheckTxnStatusResponse) String() string { return proto.CompactTextString(m) } func (*CheckTxnStatusResponse) ProtoMessage() {} func (*CheckTxnStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{13} } func (m *CheckTxnStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckTxnStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckTxnStatusResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckTxnStatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckTxnStatusResponse.Merge(dst, src) } func (m *CheckTxnStatusResponse) XXX_Size() int { return m.Size() } func (m *CheckTxnStatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckTxnStatusResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckTxnStatusResponse proto.InternalMessageInfo func (m *CheckTxnStatusResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *CheckTxnStatusResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *CheckTxnStatusResponse) GetLockTtl() uint64 { if m != nil { return m.LockTtl } return 0 } func (m *CheckTxnStatusResponse) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } func (m *CheckTxnStatusResponse) GetAction() Action { if m != nil { return m.Action } return Action_NoAction } func (m *CheckTxnStatusResponse) GetLockInfo() *LockInfo { if m != nil { return m.LockInfo } return nil } // Part of the async commit protocol, checks for locks on all supplied keys. If a lock is missing, // does not have a successful status, or belongs to another transaction, TiKV will leave a rollback // tombstone for that key. type CheckSecondaryLocksRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` // Identifies the transaction we are investigating. StartVersion uint64 `protobuf:"varint,3,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckSecondaryLocksRequest) Reset() { *m = CheckSecondaryLocksRequest{} } func (m *CheckSecondaryLocksRequest) String() string { return proto.CompactTextString(m) } func (*CheckSecondaryLocksRequest) ProtoMessage() {} func (*CheckSecondaryLocksRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{14} } func (m *CheckSecondaryLocksRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckSecondaryLocksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckSecondaryLocksRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckSecondaryLocksRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckSecondaryLocksRequest.Merge(dst, src) } func (m *CheckSecondaryLocksRequest) XXX_Size() int { return m.Size() } func (m *CheckSecondaryLocksRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckSecondaryLocksRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckSecondaryLocksRequest proto.InternalMessageInfo func (m *CheckSecondaryLocksRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *CheckSecondaryLocksRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *CheckSecondaryLocksRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } type CheckSecondaryLocksResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // For each key in `keys` in `CheckSecondaryLocks`, there will be a lock in // this list if there is a lock present and belonging to the correct transaction, // nil otherwise. Locks []*LockInfo `protobuf:"bytes,3,rep,name=locks" json:"locks,omitempty"` // If any of the locks have been committed, this is the commit ts used. If no // locks have been committed, it will be zero. CommitTs uint64 `protobuf:"varint,4,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckSecondaryLocksResponse) Reset() { *m = CheckSecondaryLocksResponse{} } func (m *CheckSecondaryLocksResponse) String() string { return proto.CompactTextString(m) } func (*CheckSecondaryLocksResponse) ProtoMessage() {} func (*CheckSecondaryLocksResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{15} } func (m *CheckSecondaryLocksResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckSecondaryLocksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckSecondaryLocksResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckSecondaryLocksResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckSecondaryLocksResponse.Merge(dst, src) } func (m *CheckSecondaryLocksResponse) XXX_Size() int { return m.Size() } func (m *CheckSecondaryLocksResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckSecondaryLocksResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckSecondaryLocksResponse proto.InternalMessageInfo func (m *CheckSecondaryLocksResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *CheckSecondaryLocksResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *CheckSecondaryLocksResponse) GetLocks() []*LockInfo { if m != nil { return m.Locks } return nil } func (m *CheckSecondaryLocksResponse) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } // The second phase of writing to TiKV. If there are no errors or conflicts, then this request // commits a transaction so that its data can be read by other transactions. type CommitRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // Identifies the transaction. StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // All keys in the transaction (to be committed). Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` // Timestamp for the end of the transaction. Must be greater than `start_version`. CommitVersion uint64 `protobuf:"varint,4,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitRequest) Reset() { *m = CommitRequest{} } func (m *CommitRequest) String() string { return proto.CompactTextString(m) } func (*CommitRequest) ProtoMessage() {} func (*CommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{16} } func (m *CommitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitRequest.Merge(dst, src) } func (m *CommitRequest) XXX_Size() int { return m.Size() } func (m *CommitRequest) XXX_DiscardUnknown() { xxx_messageInfo_CommitRequest.DiscardUnknown(m) } var xxx_messageInfo_CommitRequest proto.InternalMessageInfo func (m *CommitRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *CommitRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *CommitRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *CommitRequest) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } type CommitResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // If the commit ts is derived from min_commit_ts, this field should be set. CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitResponse) Reset() { *m = CommitResponse{} } func (m *CommitResponse) String() string { return proto.CompactTextString(m) } func (*CommitResponse) ProtoMessage() {} func (*CommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{17} } func (m *CommitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitResponse.Merge(dst, src) } func (m *CommitResponse) XXX_Size() int { return m.Size() } func (m *CommitResponse) XXX_DiscardUnknown() { xxx_messageInfo_CommitResponse.DiscardUnknown(m) } var xxx_messageInfo_CommitResponse proto.InternalMessageInfo func (m *CommitResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *CommitResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *CommitResponse) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } // Not yet implemented. type ImportRequest struct { Mutations []*Mutation `protobuf:"bytes,1,rep,name=mutations" json:"mutations,omitempty"` CommitVersion uint64 `protobuf:"varint,2,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImportRequest) Reset() { *m = ImportRequest{} } func (m *ImportRequest) String() string { return proto.CompactTextString(m) } func (*ImportRequest) ProtoMessage() {} func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{18} } func (m *ImportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ImportRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ImportRequest.Merge(dst, src) } func (m *ImportRequest) XXX_Size() int { return m.Size() } func (m *ImportRequest) XXX_DiscardUnknown() { xxx_messageInfo_ImportRequest.DiscardUnknown(m) } var xxx_messageInfo_ImportRequest proto.InternalMessageInfo func (m *ImportRequest) GetMutations() []*Mutation { if m != nil { return m.Mutations } return nil } func (m *ImportRequest) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } type ImportResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImportResponse) Reset() { *m = ImportResponse{} } func (m *ImportResponse) String() string { return proto.CompactTextString(m) } func (*ImportResponse) ProtoMessage() {} func (*ImportResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{19} } func (m *ImportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImportResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ImportResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ImportResponse.Merge(dst, src) } func (m *ImportResponse) XXX_Size() int { return m.Size() } func (m *ImportResponse) XXX_DiscardUnknown() { xxx_messageInfo_ImportResponse.DiscardUnknown(m) } var xxx_messageInfo_ImportResponse proto.InternalMessageInfo func (m *ImportResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *ImportResponse) GetError() string { if m != nil { return m.Error } return "" } // Cleanup a key by possibly unlocking it. // From 4.0 onwards, this message is no longer used. type CleanupRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` StartVersion uint64 `protobuf:"varint,3,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // The current timestamp, used in combination with a lock's TTL to determine // if the lock has expired. If `current_ts == 0`, then the key will be unlocked // irrespective of its TTL. CurrentTs uint64 `protobuf:"varint,4,opt,name=current_ts,json=currentTs,proto3" json:"current_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CleanupRequest) Reset() { *m = CleanupRequest{} } func (m *CleanupRequest) String() string { return proto.CompactTextString(m) } func (*CleanupRequest) ProtoMessage() {} func (*CleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{20} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CleanupRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CleanupRequest.Merge(dst, 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 (m *CleanupRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *CleanupRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *CleanupRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *CleanupRequest) GetCurrentTs() uint64 { if m != nil { return m.CurrentTs } return 0 } type CleanupResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // Set if the key is already committed. CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CleanupResponse) Reset() { *m = CleanupResponse{} } func (m *CleanupResponse) String() string { return proto.CompactTextString(m) } func (*CleanupResponse) ProtoMessage() {} func (*CleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{21} } func (m *CleanupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CleanupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CleanupResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CleanupResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CleanupResponse.Merge(dst, src) } func (m *CleanupResponse) XXX_Size() int { return m.Size() } func (m *CleanupResponse) XXX_DiscardUnknown() { xxx_messageInfo_CleanupResponse.DiscardUnknown(m) } var xxx_messageInfo_CleanupResponse proto.InternalMessageInfo func (m *CleanupResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *CleanupResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *CleanupResponse) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } // Similar to a `Get` request. type BatchGetRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchGetRequest) Reset() { *m = BatchGetRequest{} } func (m *BatchGetRequest) String() string { return proto.CompactTextString(m) } func (*BatchGetRequest) ProtoMessage() {} func (*BatchGetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{22} } func (m *BatchGetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchGetRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchGetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchGetRequest.Merge(dst, src) } func (m *BatchGetRequest) XXX_Size() int { return m.Size() } func (m *BatchGetRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchGetRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchGetRequest proto.InternalMessageInfo func (m *BatchGetRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *BatchGetRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *BatchGetRequest) GetVersion() uint64 { if m != nil { return m.Version } return 0 } type BatchGetResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` // Time and scan details when processing the request. ExecDetailsV2 *ExecDetailsV2 `protobuf:"bytes,4,opt,name=exec_details_v2,json=execDetailsV2" json:"exec_details_v2,omitempty"` // This KeyError exists when some key is locked but we cannot check locks of all keys. // In this case, `pairs` should be empty and the client should redo batch get all the keys // after resolving the lock. Error *KeyError `protobuf:"bytes,5,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchGetResponse) Reset() { *m = BatchGetResponse{} } func (m *BatchGetResponse) String() string { return proto.CompactTextString(m) } func (*BatchGetResponse) ProtoMessage() {} func (*BatchGetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{23} } func (m *BatchGetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchGetResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchGetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchGetResponse.Merge(dst, src) } func (m *BatchGetResponse) XXX_Size() int { return m.Size() } func (m *BatchGetResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchGetResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchGetResponse proto.InternalMessageInfo func (m *BatchGetResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *BatchGetResponse) GetPairs() []*KvPair { if m != nil { return m.Pairs } return nil } func (m *BatchGetResponse) GetExecDetailsV2() *ExecDetailsV2 { if m != nil { return m.ExecDetailsV2 } return nil } func (m *BatchGetResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } // Rollback a prewritten transaction. This will remove the preliminary data from the database, // unlock locks, and leave a rollback tombstone. type BatchRollbackRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // Identify the transaction to be rolled back. StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // The keys to rollback. Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchRollbackRequest) Reset() { *m = BatchRollbackRequest{} } func (m *BatchRollbackRequest) String() string { return proto.CompactTextString(m) } func (*BatchRollbackRequest) ProtoMessage() {} func (*BatchRollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{24} } func (m *BatchRollbackRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchRollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchRollbackRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchRollbackRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchRollbackRequest.Merge(dst, src) } func (m *BatchRollbackRequest) XXX_Size() int { return m.Size() } func (m *BatchRollbackRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchRollbackRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchRollbackRequest proto.InternalMessageInfo func (m *BatchRollbackRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *BatchRollbackRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *BatchRollbackRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } type BatchRollbackResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchRollbackResponse) Reset() { *m = BatchRollbackResponse{} } func (m *BatchRollbackResponse) String() string { return proto.CompactTextString(m) } func (*BatchRollbackResponse) ProtoMessage() {} func (*BatchRollbackResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{25} } func (m *BatchRollbackResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchRollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchRollbackResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchRollbackResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchRollbackResponse.Merge(dst, src) } func (m *BatchRollbackResponse) XXX_Size() int { return m.Size() } func (m *BatchRollbackResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchRollbackResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchRollbackResponse proto.InternalMessageInfo func (m *BatchRollbackResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *BatchRollbackResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } // Scan the database for locks. Used at the start of the GC process to find all // old locks. type ScanLockRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // Returns all locks with a start timestamp before `max_version`. MaxVersion uint64 `protobuf:"varint,2,opt,name=max_version,json=maxVersion,proto3" json:"max_version,omitempty"` // Start scanning from this key. StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` // The maximum number of locks to return. Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` // The exclusive upperbound for scanning. EndKey []byte `protobuf:"bytes,5,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanLockRequest) Reset() { *m = ScanLockRequest{} } func (m *ScanLockRequest) String() string { return proto.CompactTextString(m) } func (*ScanLockRequest) ProtoMessage() {} func (*ScanLockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{26} } func (m *ScanLockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanLockRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanLockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanLockRequest.Merge(dst, src) } func (m *ScanLockRequest) XXX_Size() int { return m.Size() } func (m *ScanLockRequest) XXX_DiscardUnknown() { xxx_messageInfo_ScanLockRequest.DiscardUnknown(m) } var xxx_messageInfo_ScanLockRequest proto.InternalMessageInfo func (m *ScanLockRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *ScanLockRequest) GetMaxVersion() uint64 { if m != nil { return m.MaxVersion } return 0 } func (m *ScanLockRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *ScanLockRequest) GetLimit() uint32 { if m != nil { return m.Limit } return 0 } func (m *ScanLockRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } type ScanLockResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` // Info on all locks found by the scan. Locks []*LockInfo `protobuf:"bytes,3,rep,name=locks" json:"locks,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanLockResponse) Reset() { *m = ScanLockResponse{} } func (m *ScanLockResponse) String() string { return proto.CompactTextString(m) } func (*ScanLockResponse) ProtoMessage() {} func (*ScanLockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{27} } func (m *ScanLockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanLockResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanLockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanLockResponse.Merge(dst, src) } func (m *ScanLockResponse) XXX_Size() int { return m.Size() } func (m *ScanLockResponse) XXX_DiscardUnknown() { xxx_messageInfo_ScanLockResponse.DiscardUnknown(m) } var xxx_messageInfo_ScanLockResponse proto.InternalMessageInfo func (m *ScanLockResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *ScanLockResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *ScanLockResponse) GetLocks() []*LockInfo { if m != nil { return m.Locks } return nil } // For all keys locked by the transaction identified by `start_version`, either // commit or rollback the transaction and unlock the key. type ResolveLockRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // `commit_version == 0` means the transaction was rolled back. // `commit_version > 0` means the transaction was committed at the given timestamp. CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` TxnInfos []*TxnInfo `protobuf:"bytes,4,rep,name=txn_infos,json=txnInfos" json:"txn_infos,omitempty"` // Only resolve specified keys. Keys [][]byte `protobuf:"bytes,5,rep,name=keys" json:"keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResolveLockRequest) Reset() { *m = ResolveLockRequest{} } func (m *ResolveLockRequest) String() string { return proto.CompactTextString(m) } func (*ResolveLockRequest) ProtoMessage() {} func (*ResolveLockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{28} } func (m *ResolveLockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResolveLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResolveLockRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResolveLockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ResolveLockRequest.Merge(dst, src) } func (m *ResolveLockRequest) XXX_Size() int { return m.Size() } func (m *ResolveLockRequest) XXX_DiscardUnknown() { xxx_messageInfo_ResolveLockRequest.DiscardUnknown(m) } var xxx_messageInfo_ResolveLockRequest proto.InternalMessageInfo func (m *ResolveLockRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *ResolveLockRequest) GetStartVersion() uint64 { if m != nil { return m.StartVersion } return 0 } func (m *ResolveLockRequest) GetCommitVersion() uint64 { if m != nil { return m.CommitVersion } return 0 } func (m *ResolveLockRequest) GetTxnInfos() []*TxnInfo { if m != nil { return m.TxnInfos } return nil } func (m *ResolveLockRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } type ResolveLockResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResolveLockResponse) Reset() { *m = ResolveLockResponse{} } func (m *ResolveLockResponse) String() string { return proto.CompactTextString(m) } func (*ResolveLockResponse) ProtoMessage() {} func (*ResolveLockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{29} } func (m *ResolveLockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResolveLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResolveLockResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResolveLockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ResolveLockResponse.Merge(dst, src) } func (m *ResolveLockResponse) XXX_Size() int { return m.Size() } func (m *ResolveLockResponse) XXX_DiscardUnknown() { xxx_messageInfo_ResolveLockResponse.DiscardUnknown(m) } var xxx_messageInfo_ResolveLockResponse proto.InternalMessageInfo func (m *ResolveLockResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *ResolveLockResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } // Request TiKV to garbage collect all non-current data older than `safe_point`. type GCRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GCRequest) Reset() { *m = GCRequest{} } func (m *GCRequest) String() string { return proto.CompactTextString(m) } func (*GCRequest) ProtoMessage() {} func (*GCRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{30} } func (m *GCRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GCRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GCRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GCRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GCRequest.Merge(dst, src) } func (m *GCRequest) XXX_Size() int { return m.Size() } func (m *GCRequest) XXX_DiscardUnknown() { xxx_messageInfo_GCRequest.DiscardUnknown(m) } var xxx_messageInfo_GCRequest proto.InternalMessageInfo func (m *GCRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *GCRequest) GetSafePoint() uint64 { if m != nil { return m.SafePoint } return 0 } type GCResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GCResponse) Reset() { *m = GCResponse{} } func (m *GCResponse) String() string { return proto.CompactTextString(m) } func (*GCResponse) ProtoMessage() {} func (*GCResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{31} } func (m *GCResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GCResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GCResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GCResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GCResponse.Merge(dst, src) } func (m *GCResponse) XXX_Size() int { return m.Size() } func (m *GCResponse) XXX_DiscardUnknown() { xxx_messageInfo_GCResponse.DiscardUnknown(m) } var xxx_messageInfo_GCResponse proto.InternalMessageInfo func (m *GCResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *GCResponse) GetError() *KeyError { if m != nil { return m.Error } return nil } // Delete a range of data from TiKV. // This message should not be used. type DeleteRangeRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // If true, the data will not be immediately deleted, but the operation will // still be replicated via Raft. This is used to notify TiKV that the data // will be deleted using `unsafe_destroy_range` soon. NotifyOnly bool `protobuf:"varint,4,opt,name=notify_only,json=notifyOnly,proto3" json:"notify_only,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRangeRequest) ProtoMessage() {} func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{32} } func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteRangeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRangeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRangeRequest.Merge(dst, src) } func (m *DeleteRangeRequest) XXX_Size() int { return m.Size() } func (m *DeleteRangeRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteRangeRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteRangeRequest proto.InternalMessageInfo func (m *DeleteRangeRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *DeleteRangeRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *DeleteRangeRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *DeleteRangeRequest) GetNotifyOnly() bool { if m != nil { return m.NotifyOnly } return false } type DeleteRangeResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } func (*DeleteRangeResponse) ProtoMessage() {} func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{33} } func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteRangeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRangeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRangeResponse.Merge(dst, src) } func (m *DeleteRangeResponse) XXX_Size() int { return m.Size() } func (m *DeleteRangeResponse) XXX_DiscardUnknown() { xxx_messageInfo_DeleteRangeResponse.DiscardUnknown(m) } var xxx_messageInfo_DeleteRangeResponse proto.InternalMessageInfo func (m *DeleteRangeResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *DeleteRangeResponse) GetError() string { if m != nil { return m.Error } return "" } type RawGetRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawGetRequest) Reset() { *m = RawGetRequest{} } func (m *RawGetRequest) String() string { return proto.CompactTextString(m) } func (*RawGetRequest) ProtoMessage() {} func (*RawGetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{34} } func (m *RawGetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawGetRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawGetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawGetRequest.Merge(dst, src) } func (m *RawGetRequest) XXX_Size() int { return m.Size() } func (m *RawGetRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawGetRequest.DiscardUnknown(m) } var xxx_messageInfo_RawGetRequest proto.InternalMessageInfo func (m *RawGetRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawGetRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *RawGetRequest) GetCf() string { if m != nil { return m.Cf } return "" } type RawGetResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` NotFound bool `protobuf:"varint,4,opt,name=not_found,json=notFound,proto3" json:"not_found,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawGetResponse) Reset() { *m = RawGetResponse{} } func (m *RawGetResponse) String() string { return proto.CompactTextString(m) } func (*RawGetResponse) ProtoMessage() {} func (*RawGetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{35} } func (m *RawGetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawGetResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawGetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawGetResponse.Merge(dst, src) } func (m *RawGetResponse) XXX_Size() int { return m.Size() } func (m *RawGetResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawGetResponse.DiscardUnknown(m) } var xxx_messageInfo_RawGetResponse proto.InternalMessageInfo func (m *RawGetResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawGetResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *RawGetResponse) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *RawGetResponse) GetNotFound() bool { if m != nil { return m.NotFound } return false } type RawBatchGetRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchGetRequest) Reset() { *m = RawBatchGetRequest{} } func (m *RawBatchGetRequest) String() string { return proto.CompactTextString(m) } func (*RawBatchGetRequest) ProtoMessage() {} func (*RawBatchGetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{36} } func (m *RawBatchGetRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchGetRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchGetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchGetRequest.Merge(dst, src) } func (m *RawBatchGetRequest) XXX_Size() int { return m.Size() } func (m *RawBatchGetRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchGetRequest.DiscardUnknown(m) } var xxx_messageInfo_RawBatchGetRequest proto.InternalMessageInfo func (m *RawBatchGetRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawBatchGetRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *RawBatchGetRequest) GetCf() string { if m != nil { return m.Cf } return "" } type RawBatchGetResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchGetResponse) Reset() { *m = RawBatchGetResponse{} } func (m *RawBatchGetResponse) String() string { return proto.CompactTextString(m) } func (*RawBatchGetResponse) ProtoMessage() {} func (*RawBatchGetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{37} } func (m *RawBatchGetResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchGetResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchGetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchGetResponse.Merge(dst, src) } func (m *RawBatchGetResponse) XXX_Size() int { return m.Size() } func (m *RawBatchGetResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchGetResponse.DiscardUnknown(m) } var xxx_messageInfo_RawBatchGetResponse proto.InternalMessageInfo func (m *RawBatchGetResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawBatchGetResponse) GetPairs() []*KvPair { if m != nil { return m.Pairs } return nil } type RawPutRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` Ttl uint64 `protobuf:"varint,5,opt,name=ttl,proto3" json:"ttl,omitempty"` ForCas bool `protobuf:"varint,6,opt,name=for_cas,json=forCas,proto3" json:"for_cas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawPutRequest) Reset() { *m = RawPutRequest{} } func (m *RawPutRequest) String() string { return proto.CompactTextString(m) } func (*RawPutRequest) ProtoMessage() {} func (*RawPutRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{38} } func (m *RawPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawPutRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawPutRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawPutRequest.Merge(dst, src) } func (m *RawPutRequest) XXX_Size() int { return m.Size() } func (m *RawPutRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawPutRequest.DiscardUnknown(m) } var xxx_messageInfo_RawPutRequest proto.InternalMessageInfo func (m *RawPutRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawPutRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *RawPutRequest) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *RawPutRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawPutRequest) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } func (m *RawPutRequest) GetForCas() bool { if m != nil { return m.ForCas } return false } type RawPutResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawPutResponse) Reset() { *m = RawPutResponse{} } func (m *RawPutResponse) String() string { return proto.CompactTextString(m) } func (*RawPutResponse) ProtoMessage() {} func (*RawPutResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{39} } func (m *RawPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawPutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawPutResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawPutResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawPutResponse.Merge(dst, src) } func (m *RawPutResponse) XXX_Size() int { return m.Size() } func (m *RawPutResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawPutResponse.DiscardUnknown(m) } var xxx_messageInfo_RawPutResponse proto.InternalMessageInfo func (m *RawPutResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawPutResponse) GetError() string { if m != nil { return m.Error } return "" } type RawBatchPutRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` Ttl uint64 `protobuf:"varint,4,opt,name=ttl,proto3" json:"ttl,omitempty"` // Deprecated: Do not use. ForCas bool `protobuf:"varint,5,opt,name=for_cas,json=forCas,proto3" json:"for_cas,omitempty"` // The time-to-live for each keys in seconds, and if the length of `ttls` // is exactly one, the ttl will be applied to all keys. Otherwise, the length // mismatch between `ttls` and `pairs` will return an error. Ttls []uint64 `protobuf:"varint,6,rep,packed,name=ttls" json:"ttls,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchPutRequest) Reset() { *m = RawBatchPutRequest{} } func (m *RawBatchPutRequest) String() string { return proto.CompactTextString(m) } func (*RawBatchPutRequest) ProtoMessage() {} func (*RawBatchPutRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{40} } func (m *RawBatchPutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchPutRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchPutRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchPutRequest.Merge(dst, src) } func (m *RawBatchPutRequest) XXX_Size() int { return m.Size() } func (m *RawBatchPutRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchPutRequest.DiscardUnknown(m) } var xxx_messageInfo_RawBatchPutRequest proto.InternalMessageInfo func (m *RawBatchPutRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawBatchPutRequest) GetPairs() []*KvPair { if m != nil { return m.Pairs } return nil } func (m *RawBatchPutRequest) GetCf() string { if m != nil { return m.Cf } return "" } // Deprecated: Do not use. func (m *RawBatchPutRequest) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } func (m *RawBatchPutRequest) GetForCas() bool { if m != nil { return m.ForCas } return false } func (m *RawBatchPutRequest) GetTtls() []uint64 { if m != nil { return m.Ttls } return nil } type RawBatchPutResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchPutResponse) Reset() { *m = RawBatchPutResponse{} } func (m *RawBatchPutResponse) String() string { return proto.CompactTextString(m) } func (*RawBatchPutResponse) ProtoMessage() {} func (*RawBatchPutResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{41} } func (m *RawBatchPutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchPutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchPutResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchPutResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchPutResponse.Merge(dst, src) } func (m *RawBatchPutResponse) XXX_Size() int { return m.Size() } func (m *RawBatchPutResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchPutResponse.DiscardUnknown(m) } var xxx_messageInfo_RawBatchPutResponse proto.InternalMessageInfo func (m *RawBatchPutResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawBatchPutResponse) GetError() string { if m != nil { return m.Error } return "" } type RawDeleteRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` ForCas bool `protobuf:"varint,4,opt,name=for_cas,json=forCas,proto3" json:"for_cas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawDeleteRequest) Reset() { *m = RawDeleteRequest{} } func (m *RawDeleteRequest) String() string { return proto.CompactTextString(m) } func (*RawDeleteRequest) ProtoMessage() {} func (*RawDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{42} } func (m *RawDeleteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawDeleteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawDeleteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawDeleteRequest.Merge(dst, src) } func (m *RawDeleteRequest) XXX_Size() int { return m.Size() } func (m *RawDeleteRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawDeleteRequest.DiscardUnknown(m) } var xxx_messageInfo_RawDeleteRequest proto.InternalMessageInfo func (m *RawDeleteRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawDeleteRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *RawDeleteRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawDeleteRequest) GetForCas() bool { if m != nil { return m.ForCas } return false } type RawDeleteResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawDeleteResponse) Reset() { *m = RawDeleteResponse{} } func (m *RawDeleteResponse) String() string { return proto.CompactTextString(m) } func (*RawDeleteResponse) ProtoMessage() {} func (*RawDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{43} } func (m *RawDeleteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawDeleteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawDeleteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawDeleteResponse.Merge(dst, src) } func (m *RawDeleteResponse) XXX_Size() int { return m.Size() } func (m *RawDeleteResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawDeleteResponse.DiscardUnknown(m) } var xxx_messageInfo_RawDeleteResponse proto.InternalMessageInfo func (m *RawDeleteResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawDeleteResponse) GetError() string { if m != nil { return m.Error } return "" } type RawBatchDeleteRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` ForCas bool `protobuf:"varint,4,opt,name=for_cas,json=forCas,proto3" json:"for_cas,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchDeleteRequest) Reset() { *m = RawBatchDeleteRequest{} } func (m *RawBatchDeleteRequest) String() string { return proto.CompactTextString(m) } func (*RawBatchDeleteRequest) ProtoMessage() {} func (*RawBatchDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{44} } func (m *RawBatchDeleteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchDeleteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchDeleteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchDeleteRequest.Merge(dst, src) } func (m *RawBatchDeleteRequest) XXX_Size() int { return m.Size() } func (m *RawBatchDeleteRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchDeleteRequest.DiscardUnknown(m) } var xxx_messageInfo_RawBatchDeleteRequest proto.InternalMessageInfo func (m *RawBatchDeleteRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawBatchDeleteRequest) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *RawBatchDeleteRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawBatchDeleteRequest) GetForCas() bool { if m != nil { return m.ForCas } return false } type RawBatchDeleteResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchDeleteResponse) Reset() { *m = RawBatchDeleteResponse{} } func (m *RawBatchDeleteResponse) String() string { return proto.CompactTextString(m) } func (*RawBatchDeleteResponse) ProtoMessage() {} func (*RawBatchDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{45} } func (m *RawBatchDeleteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchDeleteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchDeleteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchDeleteResponse.Merge(dst, src) } func (m *RawBatchDeleteResponse) XXX_Size() int { return m.Size() } func (m *RawBatchDeleteResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchDeleteResponse.DiscardUnknown(m) } var xxx_messageInfo_RawBatchDeleteResponse proto.InternalMessageInfo func (m *RawBatchDeleteResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawBatchDeleteResponse) GetError() string { if m != nil { return m.Error } return "" } type RawScanRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` // For compatibility, when scanning forward, the range to scan is [start_key, end_key), where start_key < end_key; // and when scanning backward, it scans [end_key, start_key) in descending order, where end_key < start_key. EndKey []byte `protobuf:"bytes,7,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawScanRequest) Reset() { *m = RawScanRequest{} } func (m *RawScanRequest) String() string { return proto.CompactTextString(m) } func (*RawScanRequest) ProtoMessage() {} func (*RawScanRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{46} } func (m *RawScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawScanRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawScanRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawScanRequest.Merge(dst, src) } func (m *RawScanRequest) XXX_Size() int { return m.Size() } func (m *RawScanRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawScanRequest.DiscardUnknown(m) } var xxx_messageInfo_RawScanRequest proto.InternalMessageInfo func (m *RawScanRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawScanRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *RawScanRequest) GetLimit() uint32 { if m != nil { return m.Limit } return 0 } func (m *RawScanRequest) GetKeyOnly() bool { if m != nil { return m.KeyOnly } return false } func (m *RawScanRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawScanRequest) GetReverse() bool { if m != nil { return m.Reverse } return false } func (m *RawScanRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } type RawScanResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawScanResponse) Reset() { *m = RawScanResponse{} } func (m *RawScanResponse) String() string { return proto.CompactTextString(m) } func (*RawScanResponse) ProtoMessage() {} func (*RawScanResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{47} } func (m *RawScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawScanResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawScanResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawScanResponse.Merge(dst, src) } func (m *RawScanResponse) XXX_Size() int { return m.Size() } func (m *RawScanResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawScanResponse.DiscardUnknown(m) } var xxx_messageInfo_RawScanResponse proto.InternalMessageInfo func (m *RawScanResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawScanResponse) GetKvs() []*KvPair { if m != nil { return m.Kvs } return nil } type RawDeleteRangeRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawDeleteRangeRequest) Reset() { *m = RawDeleteRangeRequest{} } func (m *RawDeleteRangeRequest) String() string { return proto.CompactTextString(m) } func (*RawDeleteRangeRequest) ProtoMessage() {} func (*RawDeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{48} } func (m *RawDeleteRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawDeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawDeleteRangeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawDeleteRangeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawDeleteRangeRequest.Merge(dst, src) } func (m *RawDeleteRangeRequest) XXX_Size() int { return m.Size() } func (m *RawDeleteRangeRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawDeleteRangeRequest.DiscardUnknown(m) } var xxx_messageInfo_RawDeleteRangeRequest proto.InternalMessageInfo func (m *RawDeleteRangeRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawDeleteRangeRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *RawDeleteRangeRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *RawDeleteRangeRequest) GetCf() string { if m != nil { return m.Cf } return "" } type RawDeleteRangeResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawDeleteRangeResponse) Reset() { *m = RawDeleteRangeResponse{} } func (m *RawDeleteRangeResponse) String() string { return proto.CompactTextString(m) } func (*RawDeleteRangeResponse) ProtoMessage() {} func (*RawDeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{49} } func (m *RawDeleteRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawDeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawDeleteRangeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawDeleteRangeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawDeleteRangeResponse.Merge(dst, src) } func (m *RawDeleteRangeResponse) XXX_Size() int { return m.Size() } func (m *RawDeleteRangeResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawDeleteRangeResponse.DiscardUnknown(m) } var xxx_messageInfo_RawDeleteRangeResponse proto.InternalMessageInfo func (m *RawDeleteRangeResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawDeleteRangeResponse) GetError() string { if m != nil { return m.Error } return "" } type RawBatchScanRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Ranges []*KeyRange `protobuf:"bytes,2,rep,name=ranges" json:"ranges,omitempty"` EachLimit uint32 `protobuf:"varint,3,opt,name=each_limit,json=eachLimit,proto3" json:"each_limit,omitempty"` KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchScanRequest) Reset() { *m = RawBatchScanRequest{} } func (m *RawBatchScanRequest) String() string { return proto.CompactTextString(m) } func (*RawBatchScanRequest) ProtoMessage() {} func (*RawBatchScanRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{50} } func (m *RawBatchScanRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchScanRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchScanRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchScanRequest.Merge(dst, src) } func (m *RawBatchScanRequest) XXX_Size() int { return m.Size() } func (m *RawBatchScanRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchScanRequest.DiscardUnknown(m) } var xxx_messageInfo_RawBatchScanRequest proto.InternalMessageInfo func (m *RawBatchScanRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawBatchScanRequest) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } func (m *RawBatchScanRequest) GetEachLimit() uint32 { if m != nil { return m.EachLimit } return 0 } func (m *RawBatchScanRequest) GetKeyOnly() bool { if m != nil { return m.KeyOnly } return false } func (m *RawBatchScanRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawBatchScanRequest) GetReverse() bool { if m != nil { return m.Reverse } return false } type RawBatchScanResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawBatchScanResponse) Reset() { *m = RawBatchScanResponse{} } func (m *RawBatchScanResponse) String() string { return proto.CompactTextString(m) } func (*RawBatchScanResponse) ProtoMessage() {} func (*RawBatchScanResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{51} } func (m *RawBatchScanResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawBatchScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawBatchScanResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawBatchScanResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawBatchScanResponse.Merge(dst, src) } func (m *RawBatchScanResponse) XXX_Size() int { return m.Size() } func (m *RawBatchScanResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawBatchScanResponse.DiscardUnknown(m) } var xxx_messageInfo_RawBatchScanResponse proto.InternalMessageInfo func (m *RawBatchScanResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawBatchScanResponse) GetKvs() []*KvPair { if m != nil { return m.Kvs } return nil } type UnsafeDestroyRangeRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UnsafeDestroyRangeRequest) Reset() { *m = UnsafeDestroyRangeRequest{} } func (m *UnsafeDestroyRangeRequest) String() string { return proto.CompactTextString(m) } func (*UnsafeDestroyRangeRequest) ProtoMessage() {} func (*UnsafeDestroyRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{52} } func (m *UnsafeDestroyRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UnsafeDestroyRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UnsafeDestroyRangeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UnsafeDestroyRangeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UnsafeDestroyRangeRequest.Merge(dst, src) } func (m *UnsafeDestroyRangeRequest) XXX_Size() int { return m.Size() } func (m *UnsafeDestroyRangeRequest) XXX_DiscardUnknown() { xxx_messageInfo_UnsafeDestroyRangeRequest.DiscardUnknown(m) } var xxx_messageInfo_UnsafeDestroyRangeRequest proto.InternalMessageInfo func (m *UnsafeDestroyRangeRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *UnsafeDestroyRangeRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *UnsafeDestroyRangeRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } type UnsafeDestroyRangeResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UnsafeDestroyRangeResponse) Reset() { *m = UnsafeDestroyRangeResponse{} } func (m *UnsafeDestroyRangeResponse) String() string { return proto.CompactTextString(m) } func (*UnsafeDestroyRangeResponse) ProtoMessage() {} func (*UnsafeDestroyRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{53} } func (m *UnsafeDestroyRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UnsafeDestroyRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UnsafeDestroyRangeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UnsafeDestroyRangeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UnsafeDestroyRangeResponse.Merge(dst, src) } func (m *UnsafeDestroyRangeResponse) XXX_Size() int { return m.Size() } func (m *UnsafeDestroyRangeResponse) XXX_DiscardUnknown() { xxx_messageInfo_UnsafeDestroyRangeResponse.DiscardUnknown(m) } var xxx_messageInfo_UnsafeDestroyRangeResponse proto.InternalMessageInfo func (m *UnsafeDestroyRangeResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *UnsafeDestroyRangeResponse) GetError() string { if m != nil { return m.Error } return "" } type RegisterLockObserverRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` MaxTs uint64 `protobuf:"varint,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegisterLockObserverRequest) Reset() { *m = RegisterLockObserverRequest{} } func (m *RegisterLockObserverRequest) String() string { return proto.CompactTextString(m) } func (*RegisterLockObserverRequest) ProtoMessage() {} func (*RegisterLockObserverRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{54} } func (m *RegisterLockObserverRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegisterLockObserverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegisterLockObserverRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegisterLockObserverRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegisterLockObserverRequest.Merge(dst, src) } func (m *RegisterLockObserverRequest) XXX_Size() int { return m.Size() } func (m *RegisterLockObserverRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegisterLockObserverRequest.DiscardUnknown(m) } var xxx_messageInfo_RegisterLockObserverRequest proto.InternalMessageInfo func (m *RegisterLockObserverRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RegisterLockObserverRequest) GetMaxTs() uint64 { if m != nil { return m.MaxTs } return 0 } type RegisterLockObserverResponse struct { Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegisterLockObserverResponse) Reset() { *m = RegisterLockObserverResponse{} } func (m *RegisterLockObserverResponse) String() string { return proto.CompactTextString(m) } func (*RegisterLockObserverResponse) ProtoMessage() {} func (*RegisterLockObserverResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{55} } func (m *RegisterLockObserverResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegisterLockObserverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegisterLockObserverResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegisterLockObserverResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegisterLockObserverResponse.Merge(dst, src) } func (m *RegisterLockObserverResponse) XXX_Size() int { return m.Size() } func (m *RegisterLockObserverResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegisterLockObserverResponse.DiscardUnknown(m) } var xxx_messageInfo_RegisterLockObserverResponse proto.InternalMessageInfo func (m *RegisterLockObserverResponse) GetError() string { if m != nil { return m.Error } return "" } type CheckLockObserverRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` MaxTs uint64 `protobuf:"varint,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckLockObserverRequest) Reset() { *m = CheckLockObserverRequest{} } func (m *CheckLockObserverRequest) String() string { return proto.CompactTextString(m) } func (*CheckLockObserverRequest) ProtoMessage() {} func (*CheckLockObserverRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{56} } func (m *CheckLockObserverRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckLockObserverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckLockObserverRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckLockObserverRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckLockObserverRequest.Merge(dst, src) } func (m *CheckLockObserverRequest) XXX_Size() int { return m.Size() } func (m *CheckLockObserverRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckLockObserverRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckLockObserverRequest proto.InternalMessageInfo func (m *CheckLockObserverRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *CheckLockObserverRequest) GetMaxTs() uint64 { if m != nil { return m.MaxTs } return 0 } type CheckLockObserverResponse struct { Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` IsClean bool `protobuf:"varint,2,opt,name=is_clean,json=isClean,proto3" json:"is_clean,omitempty"` Locks []*LockInfo `protobuf:"bytes,3,rep,name=locks" json:"locks,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckLockObserverResponse) Reset() { *m = CheckLockObserverResponse{} } func (m *CheckLockObserverResponse) String() string { return proto.CompactTextString(m) } func (*CheckLockObserverResponse) ProtoMessage() {} func (*CheckLockObserverResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{57} } func (m *CheckLockObserverResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckLockObserverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckLockObserverResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckLockObserverResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckLockObserverResponse.Merge(dst, src) } func (m *CheckLockObserverResponse) XXX_Size() int { return m.Size() } func (m *CheckLockObserverResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckLockObserverResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckLockObserverResponse proto.InternalMessageInfo func (m *CheckLockObserverResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *CheckLockObserverResponse) GetIsClean() bool { if m != nil { return m.IsClean } return false } func (m *CheckLockObserverResponse) GetLocks() []*LockInfo { if m != nil { return m.Locks } return nil } type RemoveLockObserverRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` MaxTs uint64 `protobuf:"varint,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveLockObserverRequest) Reset() { *m = RemoveLockObserverRequest{} } func (m *RemoveLockObserverRequest) String() string { return proto.CompactTextString(m) } func (*RemoveLockObserverRequest) ProtoMessage() {} func (*RemoveLockObserverRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{58} } func (m *RemoveLockObserverRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveLockObserverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveLockObserverRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RemoveLockObserverRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveLockObserverRequest.Merge(dst, src) } func (m *RemoveLockObserverRequest) XXX_Size() int { return m.Size() } func (m *RemoveLockObserverRequest) XXX_DiscardUnknown() { xxx_messageInfo_RemoveLockObserverRequest.DiscardUnknown(m) } var xxx_messageInfo_RemoveLockObserverRequest proto.InternalMessageInfo func (m *RemoveLockObserverRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RemoveLockObserverRequest) GetMaxTs() uint64 { if m != nil { return m.MaxTs } return 0 } type RemoveLockObserverResponse struct { Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveLockObserverResponse) Reset() { *m = RemoveLockObserverResponse{} } func (m *RemoveLockObserverResponse) String() string { return proto.CompactTextString(m) } func (*RemoveLockObserverResponse) ProtoMessage() {} func (*RemoveLockObserverResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{59} } func (m *RemoveLockObserverResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveLockObserverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveLockObserverResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RemoveLockObserverResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveLockObserverResponse.Merge(dst, src) } func (m *RemoveLockObserverResponse) XXX_Size() int { return m.Size() } func (m *RemoveLockObserverResponse) XXX_DiscardUnknown() { xxx_messageInfo_RemoveLockObserverResponse.DiscardUnknown(m) } var xxx_messageInfo_RemoveLockObserverResponse proto.InternalMessageInfo func (m *RemoveLockObserverResponse) GetError() string { if m != nil { return m.Error } return "" } type PhysicalScanLockRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` MaxTs uint64 `protobuf:"varint,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PhysicalScanLockRequest) Reset() { *m = PhysicalScanLockRequest{} } func (m *PhysicalScanLockRequest) String() string { return proto.CompactTextString(m) } func (*PhysicalScanLockRequest) ProtoMessage() {} func (*PhysicalScanLockRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{60} } func (m *PhysicalScanLockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PhysicalScanLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PhysicalScanLockRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PhysicalScanLockRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PhysicalScanLockRequest.Merge(dst, src) } func (m *PhysicalScanLockRequest) XXX_Size() int { return m.Size() } func (m *PhysicalScanLockRequest) XXX_DiscardUnknown() { xxx_messageInfo_PhysicalScanLockRequest.DiscardUnknown(m) } var xxx_messageInfo_PhysicalScanLockRequest proto.InternalMessageInfo func (m *PhysicalScanLockRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *PhysicalScanLockRequest) GetMaxTs() uint64 { if m != nil { return m.MaxTs } return 0 } func (m *PhysicalScanLockRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *PhysicalScanLockRequest) GetLimit() uint32 { if m != nil { return m.Limit } return 0 } type PhysicalScanLockResponse struct { Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` Locks []*LockInfo `protobuf:"bytes,2,rep,name=locks" json:"locks,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PhysicalScanLockResponse) Reset() { *m = PhysicalScanLockResponse{} } func (m *PhysicalScanLockResponse) String() string { return proto.CompactTextString(m) } func (*PhysicalScanLockResponse) ProtoMessage() {} func (*PhysicalScanLockResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{61} } func (m *PhysicalScanLockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PhysicalScanLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PhysicalScanLockResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PhysicalScanLockResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PhysicalScanLockResponse.Merge(dst, src) } func (m *PhysicalScanLockResponse) XXX_Size() int { return m.Size() } func (m *PhysicalScanLockResponse) XXX_DiscardUnknown() { xxx_messageInfo_PhysicalScanLockResponse.DiscardUnknown(m) } var xxx_messageInfo_PhysicalScanLockResponse proto.InternalMessageInfo func (m *PhysicalScanLockResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *PhysicalScanLockResponse) GetLocks() []*LockInfo { if m != nil { return m.Locks } return nil } // Sent from PD to a TiKV node. type SplitRegionRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` SplitKey []byte `protobuf:"bytes,2,opt,name=split_key,json=splitKey,proto3" json:"split_key,omitempty"` // Deprecated: Do not use. SplitKeys [][]byte `protobuf:"bytes,3,rep,name=split_keys,json=splitKeys" json:"split_keys,omitempty"` // Once enabled, the split_key will not be encoded. IsRawKv bool `protobuf:"varint,4,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRegionRequest) Reset() { *m = SplitRegionRequest{} } func (m *SplitRegionRequest) String() string { return proto.CompactTextString(m) } func (*SplitRegionRequest) ProtoMessage() {} func (*SplitRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{62} } func (m *SplitRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRegionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRegionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRegionRequest.Merge(dst, src) } func (m *SplitRegionRequest) XXX_Size() int { return m.Size() } func (m *SplitRegionRequest) XXX_DiscardUnknown() { xxx_messageInfo_SplitRegionRequest.DiscardUnknown(m) } var xxx_messageInfo_SplitRegionRequest proto.InternalMessageInfo func (m *SplitRegionRequest) GetContext() *Context { if m != nil { return m.Context } return nil } // Deprecated: Do not use. func (m *SplitRegionRequest) GetSplitKey() []byte { if m != nil { return m.SplitKey } return nil } func (m *SplitRegionRequest) GetSplitKeys() [][]byte { if m != nil { return m.SplitKeys } return nil } func (m *SplitRegionRequest) GetIsRawKv() bool { if m != nil { return m.IsRawKv } return false } type SplitRegionResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` // Deprecated: Do not use. Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` // Deprecated: Do not use. Regions []*metapb.Region `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRegionResponse) Reset() { *m = SplitRegionResponse{} } func (m *SplitRegionResponse) String() string { return proto.CompactTextString(m) } func (*SplitRegionResponse) ProtoMessage() {} func (*SplitRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{63} } func (m *SplitRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRegionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRegionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRegionResponse.Merge(dst, src) } func (m *SplitRegionResponse) XXX_Size() int { return m.Size() } func (m *SplitRegionResponse) XXX_DiscardUnknown() { xxx_messageInfo_SplitRegionResponse.DiscardUnknown(m) } var xxx_messageInfo_SplitRegionResponse proto.InternalMessageInfo func (m *SplitRegionResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } // Deprecated: Do not use. func (m *SplitRegionResponse) GetLeft() *metapb.Region { if m != nil { return m.Left } return nil } // Deprecated: Do not use. func (m *SplitRegionResponse) GetRight() *metapb.Region { if m != nil { return m.Right } return nil } func (m *SplitRegionResponse) GetRegions() []*metapb.Region { if m != nil { return m.Regions } return nil } // Sent from TiFlash to a TiKV node. type ReadIndexRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` // TiKV checks the given range if there is any unapplied lock // blocking the read request. StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Ranges []*KeyRange `protobuf:"bytes,3,rep,name=ranges" json:"ranges,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadIndexRequest) Reset() { *m = ReadIndexRequest{} } func (m *ReadIndexRequest) String() string { return proto.CompactTextString(m) } func (*ReadIndexRequest) ProtoMessage() {} func (*ReadIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{64} } func (m *ReadIndexRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadIndexRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadIndexRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadIndexRequest.Merge(dst, src) } func (m *ReadIndexRequest) XXX_Size() int { return m.Size() } func (m *ReadIndexRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReadIndexRequest.DiscardUnknown(m) } var xxx_messageInfo_ReadIndexRequest proto.InternalMessageInfo func (m *ReadIndexRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *ReadIndexRequest) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *ReadIndexRequest) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } type ReadIndexResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` ReadIndex uint64 `protobuf:"varint,2,opt,name=read_index,json=readIndex,proto3" json:"read_index,omitempty"` // If `locked` is set, this read request is blocked by a lock. // The lock should be returned to the client. Locked *LockInfo `protobuf:"bytes,3,opt,name=locked" json:"locked,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadIndexResponse) Reset() { *m = ReadIndexResponse{} } func (m *ReadIndexResponse) String() string { return proto.CompactTextString(m) } func (*ReadIndexResponse) ProtoMessage() {} func (*ReadIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{65} } func (m *ReadIndexResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadIndexResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadIndexResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadIndexResponse.Merge(dst, src) } func (m *ReadIndexResponse) XXX_Size() int { return m.Size() } func (m *ReadIndexResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReadIndexResponse.DiscardUnknown(m) } var xxx_messageInfo_ReadIndexResponse proto.InternalMessageInfo func (m *ReadIndexResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *ReadIndexResponse) GetReadIndex() uint64 { if m != nil { return m.ReadIndex } return 0 } func (m *ReadIndexResponse) GetLocked() *LockInfo { if m != nil { return m.Locked } return nil } type MvccGetByKeyRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccGetByKeyRequest) Reset() { *m = MvccGetByKeyRequest{} } func (m *MvccGetByKeyRequest) String() string { return proto.CompactTextString(m) } func (*MvccGetByKeyRequest) ProtoMessage() {} func (*MvccGetByKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{66} } func (m *MvccGetByKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccGetByKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccGetByKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccGetByKeyRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccGetByKeyRequest.Merge(dst, src) } func (m *MvccGetByKeyRequest) XXX_Size() int { return m.Size() } func (m *MvccGetByKeyRequest) XXX_DiscardUnknown() { xxx_messageInfo_MvccGetByKeyRequest.DiscardUnknown(m) } var xxx_messageInfo_MvccGetByKeyRequest proto.InternalMessageInfo func (m *MvccGetByKeyRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *MvccGetByKeyRequest) GetKey() []byte { if m != nil { return m.Key } return nil } type MvccGetByKeyResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Info *MvccInfo `protobuf:"bytes,3,opt,name=info" json:"info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccGetByKeyResponse) Reset() { *m = MvccGetByKeyResponse{} } func (m *MvccGetByKeyResponse) String() string { return proto.CompactTextString(m) } func (*MvccGetByKeyResponse) ProtoMessage() {} func (*MvccGetByKeyResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{67} } func (m *MvccGetByKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccGetByKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccGetByKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccGetByKeyResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccGetByKeyResponse.Merge(dst, src) } func (m *MvccGetByKeyResponse) XXX_Size() int { return m.Size() } func (m *MvccGetByKeyResponse) XXX_DiscardUnknown() { xxx_messageInfo_MvccGetByKeyResponse.DiscardUnknown(m) } var xxx_messageInfo_MvccGetByKeyResponse proto.InternalMessageInfo func (m *MvccGetByKeyResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *MvccGetByKeyResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *MvccGetByKeyResponse) GetInfo() *MvccInfo { if m != nil { return m.Info } return nil } type MvccGetByStartTsRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccGetByStartTsRequest) Reset() { *m = MvccGetByStartTsRequest{} } func (m *MvccGetByStartTsRequest) String() string { return proto.CompactTextString(m) } func (*MvccGetByStartTsRequest) ProtoMessage() {} func (*MvccGetByStartTsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{68} } func (m *MvccGetByStartTsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccGetByStartTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccGetByStartTsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccGetByStartTsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccGetByStartTsRequest.Merge(dst, src) } func (m *MvccGetByStartTsRequest) XXX_Size() int { return m.Size() } func (m *MvccGetByStartTsRequest) XXX_DiscardUnknown() { xxx_messageInfo_MvccGetByStartTsRequest.DiscardUnknown(m) } var xxx_messageInfo_MvccGetByStartTsRequest proto.InternalMessageInfo func (m *MvccGetByStartTsRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *MvccGetByStartTsRequest) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } type MvccGetByStartTsResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` Info *MvccInfo `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccGetByStartTsResponse) Reset() { *m = MvccGetByStartTsResponse{} } func (m *MvccGetByStartTsResponse) String() string { return proto.CompactTextString(m) } func (*MvccGetByStartTsResponse) ProtoMessage() {} func (*MvccGetByStartTsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{69} } func (m *MvccGetByStartTsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccGetByStartTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccGetByStartTsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccGetByStartTsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccGetByStartTsResponse.Merge(dst, src) } func (m *MvccGetByStartTsResponse) XXX_Size() int { return m.Size() } func (m *MvccGetByStartTsResponse) XXX_DiscardUnknown() { xxx_messageInfo_MvccGetByStartTsResponse.DiscardUnknown(m) } var xxx_messageInfo_MvccGetByStartTsResponse proto.InternalMessageInfo func (m *MvccGetByStartTsResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *MvccGetByStartTsResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *MvccGetByStartTsResponse) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *MvccGetByStartTsResponse) GetInfo() *MvccInfo { if m != nil { return m.Info } return nil } // Miscellaneous metadata attached to most requests. type Context struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` Peer *metapb.Peer `protobuf:"bytes,3,opt,name=peer" json:"peer,omitempty"` Term uint64 `protobuf:"varint,5,opt,name=term,proto3" json:"term,omitempty"` Priority CommandPri `protobuf:"varint,6,opt,name=priority,proto3,enum=kvrpcpb.CommandPri" json:"priority,omitempty"` IsolationLevel IsolationLevel `protobuf:"varint,7,opt,name=isolation_level,json=isolationLevel,proto3,enum=kvrpcpb.IsolationLevel" json:"isolation_level,omitempty"` NotFillCache bool `protobuf:"varint,8,opt,name=not_fill_cache,json=notFillCache,proto3" json:"not_fill_cache,omitempty"` SyncLog bool `protobuf:"varint,9,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` // True means execution time statistics should be recorded and returned. RecordTimeStat bool `protobuf:"varint,10,opt,name=record_time_stat,json=recordTimeStat,proto3" json:"record_time_stat,omitempty"` // True means RocksDB scan statistics should be recorded and returned. RecordScanStat bool `protobuf:"varint,11,opt,name=record_scan_stat,json=recordScanStat,proto3" json:"record_scan_stat,omitempty"` ReplicaRead bool `protobuf:"varint,12,opt,name=replica_read,json=replicaRead,proto3" json:"replica_read,omitempty"` // Read requests can ignore locks belonging to these transactions because either // these transactions are rolled back or theirs commit_ts > read request's start_ts. ResolvedLocks []uint64 `protobuf:"varint,13,rep,packed,name=resolved_locks,json=resolvedLocks" json:"resolved_locks,omitempty"` MaxExecutionDurationMs uint64 `protobuf:"varint,14,opt,name=max_execution_duration_ms,json=maxExecutionDurationMs,proto3" json:"max_execution_duration_ms,omitempty"` // After a region applies to `applied_index`, we can get a // snapshot for the region even if the peer is a follower. AppliedIndex uint64 `protobuf:"varint,15,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` // A hint for TiKV to schedule tasks more fairly. Query with same task ID // may share same priority and resource quota. TaskId uint64 `protobuf:"varint,16,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` // Not required to read the most up-to-date data, replicas with `safe_ts` >= `start_ts` // can handle read request directly StaleRead bool `protobuf:"varint,17,opt,name=stale_read,json=staleRead,proto3" json:"stale_read,omitempty"` // Any additional serialized information about the request. ResourceGroupTag []byte `protobuf:"bytes,18,opt,name=resource_group_tag,json=resourceGroupTag,proto3" json:"resource_group_tag,omitempty"` // Used to tell TiKV whether operations are allowed or not on different disk usages. DiskFullOpt DiskFullOpt `protobuf:"varint,19,opt,name=disk_full_opt,json=diskFullOpt,proto3,enum=kvrpcpb.DiskFullOpt" json:"disk_full_opt,omitempty"` // Indicates the request is a retry request and the same request may have been sent before. IsRetryRequest bool `protobuf:"varint,20,opt,name=is_retry_request,json=isRetryRequest,proto3" json:"is_retry_request,omitempty"` // API version implies the encode of the key and value. ApiVersion APIVersion `protobuf:"varint,21,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` // Read request should read through locks belonging to these transactions because these // transactions are committed and theirs commit_ts <= read request's start_ts. CommittedLocks []uint64 `protobuf:"varint,22,rep,packed,name=committed_locks,json=committedLocks" json:"committed_locks,omitempty"` // The informantion to trace a request sent to TiKV. TraceContext *tracepb.TraceContext `protobuf:"bytes,23,opt,name=trace_context,json=traceContext" json:"trace_context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Context) Reset() { *m = Context{} } func (m *Context) String() string { return proto.CompactTextString(m) } func (*Context) ProtoMessage() {} func (*Context) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{70} } func (m *Context) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Context) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Context.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Context) XXX_Merge(src proto.Message) { xxx_messageInfo_Context.Merge(dst, src) } func (m *Context) XXX_Size() int { return m.Size() } func (m *Context) XXX_DiscardUnknown() { xxx_messageInfo_Context.DiscardUnknown(m) } var xxx_messageInfo_Context proto.InternalMessageInfo func (m *Context) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *Context) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *Context) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *Context) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *Context) GetPriority() CommandPri { if m != nil { return m.Priority } return CommandPri_Normal } func (m *Context) GetIsolationLevel() IsolationLevel { if m != nil { return m.IsolationLevel } return IsolationLevel_SI } func (m *Context) GetNotFillCache() bool { if m != nil { return m.NotFillCache } return false } func (m *Context) GetSyncLog() bool { if m != nil { return m.SyncLog } return false } func (m *Context) GetRecordTimeStat() bool { if m != nil { return m.RecordTimeStat } return false } func (m *Context) GetRecordScanStat() bool { if m != nil { return m.RecordScanStat } return false } func (m *Context) GetReplicaRead() bool { if m != nil { return m.ReplicaRead } return false } func (m *Context) GetResolvedLocks() []uint64 { if m != nil { return m.ResolvedLocks } return nil } func (m *Context) GetMaxExecutionDurationMs() uint64 { if m != nil { return m.MaxExecutionDurationMs } return 0 } func (m *Context) GetAppliedIndex() uint64 { if m != nil { return m.AppliedIndex } return 0 } func (m *Context) GetTaskId() uint64 { if m != nil { return m.TaskId } return 0 } func (m *Context) GetStaleRead() bool { if m != nil { return m.StaleRead } return false } func (m *Context) GetResourceGroupTag() []byte { if m != nil { return m.ResourceGroupTag } return nil } func (m *Context) GetDiskFullOpt() DiskFullOpt { if m != nil { return m.DiskFullOpt } return DiskFullOpt_NotAllowedOnFull } func (m *Context) GetIsRetryRequest() bool { if m != nil { return m.IsRetryRequest } return false } func (m *Context) GetApiVersion() APIVersion { if m != nil { return m.ApiVersion } return APIVersion_V1 } func (m *Context) GetCommittedLocks() []uint64 { if m != nil { return m.CommittedLocks } return nil } func (m *Context) GetTraceContext() *tracepb.TraceContext { if m != nil { return m.TraceContext } return nil } type LockInfo struct { PrimaryLock []byte `protobuf:"bytes,1,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` LockVersion uint64 `protobuf:"varint,2,opt,name=lock_version,json=lockVersion,proto3" json:"lock_version,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` LockTtl uint64 `protobuf:"varint,4,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` // How many keys this transaction involves in this region. TxnSize uint64 `protobuf:"varint,5,opt,name=txn_size,json=txnSize,proto3" json:"txn_size,omitempty"` LockType Op `protobuf:"varint,6,opt,name=lock_type,json=lockType,proto3,enum=kvrpcpb.Op" json:"lock_type,omitempty"` LockForUpdateTs uint64 `protobuf:"varint,7,opt,name=lock_for_update_ts,json=lockForUpdateTs,proto3" json:"lock_for_update_ts,omitempty"` // Fields for transactions that are using Async Commit. UseAsyncCommit bool `protobuf:"varint,8,opt,name=use_async_commit,json=useAsyncCommit,proto3" json:"use_async_commit,omitempty"` MinCommitTs uint64 `protobuf:"varint,9,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` Secondaries [][]byte `protobuf:"bytes,10,rep,name=secondaries" json:"secondaries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LockInfo) Reset() { *m = LockInfo{} } func (m *LockInfo) String() string { return proto.CompactTextString(m) } func (*LockInfo) ProtoMessage() {} func (*LockInfo) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{71} } func (m *LockInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LockInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LockInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_LockInfo.Merge(dst, src) } func (m *LockInfo) XXX_Size() int { return m.Size() } func (m *LockInfo) XXX_DiscardUnknown() { xxx_messageInfo_LockInfo.DiscardUnknown(m) } var xxx_messageInfo_LockInfo proto.InternalMessageInfo func (m *LockInfo) GetPrimaryLock() []byte { if m != nil { return m.PrimaryLock } return nil } func (m *LockInfo) GetLockVersion() uint64 { if m != nil { return m.LockVersion } return 0 } func (m *LockInfo) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *LockInfo) GetLockTtl() uint64 { if m != nil { return m.LockTtl } return 0 } func (m *LockInfo) GetTxnSize() uint64 { if m != nil { return m.TxnSize } return 0 } func (m *LockInfo) GetLockType() Op { if m != nil { return m.LockType } return Op_Put } func (m *LockInfo) GetLockForUpdateTs() uint64 { if m != nil { return m.LockForUpdateTs } return 0 } func (m *LockInfo) GetUseAsyncCommit() bool { if m != nil { return m.UseAsyncCommit } return false } func (m *LockInfo) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } func (m *LockInfo) GetSecondaries() [][]byte { if m != nil { return m.Secondaries } return nil } type KeyError struct { Locked *LockInfo `protobuf:"bytes,1,opt,name=locked" json:"locked,omitempty"` Retryable string `protobuf:"bytes,2,opt,name=retryable,proto3" json:"retryable,omitempty"` Abort string `protobuf:"bytes,3,opt,name=abort,proto3" json:"abort,omitempty"` Conflict *WriteConflict `protobuf:"bytes,4,opt,name=conflict" json:"conflict,omitempty"` AlreadyExist *AlreadyExist `protobuf:"bytes,5,opt,name=already_exist,json=alreadyExist" json:"already_exist,omitempty"` Deadlock *Deadlock `protobuf:"bytes,6,opt,name=deadlock" json:"deadlock,omitempty"` CommitTsExpired *CommitTsExpired `protobuf:"bytes,7,opt,name=commit_ts_expired,json=commitTsExpired" json:"commit_ts_expired,omitempty"` TxnNotFound *TxnNotFound `protobuf:"bytes,8,opt,name=txn_not_found,json=txnNotFound" json:"txn_not_found,omitempty"` CommitTsTooLarge *CommitTsTooLarge `protobuf:"bytes,9,opt,name=commit_ts_too_large,json=commitTsTooLarge" json:"commit_ts_too_large,omitempty"` AssertionFailed *AssertionFailed `protobuf:"bytes,10,opt,name=assertion_failed,json=assertionFailed" json:"assertion_failed,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyError) Reset() { *m = KeyError{} } func (m *KeyError) String() string { return proto.CompactTextString(m) } func (*KeyError) ProtoMessage() {} func (*KeyError) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{72} } func (m *KeyError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyError.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyError) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyError.Merge(dst, src) } func (m *KeyError) XXX_Size() int { return m.Size() } func (m *KeyError) XXX_DiscardUnknown() { xxx_messageInfo_KeyError.DiscardUnknown(m) } var xxx_messageInfo_KeyError proto.InternalMessageInfo func (m *KeyError) GetLocked() *LockInfo { if m != nil { return m.Locked } return nil } func (m *KeyError) GetRetryable() string { if m != nil { return m.Retryable } return "" } func (m *KeyError) GetAbort() string { if m != nil { return m.Abort } return "" } func (m *KeyError) GetConflict() *WriteConflict { if m != nil { return m.Conflict } return nil } func (m *KeyError) GetAlreadyExist() *AlreadyExist { if m != nil { return m.AlreadyExist } return nil } func (m *KeyError) GetDeadlock() *Deadlock { if m != nil { return m.Deadlock } return nil } func (m *KeyError) GetCommitTsExpired() *CommitTsExpired { if m != nil { return m.CommitTsExpired } return nil } func (m *KeyError) GetTxnNotFound() *TxnNotFound { if m != nil { return m.TxnNotFound } return nil } func (m *KeyError) GetCommitTsTooLarge() *CommitTsTooLarge { if m != nil { return m.CommitTsTooLarge } return nil } func (m *KeyError) GetAssertionFailed() *AssertionFailed { if m != nil { return m.AssertionFailed } return nil } type WriteConflict struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` ConflictTs uint64 `protobuf:"varint,2,opt,name=conflict_ts,json=conflictTs,proto3" json:"conflict_ts,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` Primary []byte `protobuf:"bytes,4,opt,name=primary,proto3" json:"primary,omitempty"` ConflictCommitTs uint64 `protobuf:"varint,5,opt,name=conflict_commit_ts,json=conflictCommitTs,proto3" json:"conflict_commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WriteConflict) Reset() { *m = WriteConflict{} } func (m *WriteConflict) String() string { return proto.CompactTextString(m) } func (*WriteConflict) ProtoMessage() {} func (*WriteConflict) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{73} } func (m *WriteConflict) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WriteConflict) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WriteConflict.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WriteConflict) XXX_Merge(src proto.Message) { xxx_messageInfo_WriteConflict.Merge(dst, src) } func (m *WriteConflict) XXX_Size() int { return m.Size() } func (m *WriteConflict) XXX_DiscardUnknown() { xxx_messageInfo_WriteConflict.DiscardUnknown(m) } var xxx_messageInfo_WriteConflict proto.InternalMessageInfo func (m *WriteConflict) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *WriteConflict) GetConflictTs() uint64 { if m != nil { return m.ConflictTs } return 0 } func (m *WriteConflict) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *WriteConflict) GetPrimary() []byte { if m != nil { return m.Primary } return nil } func (m *WriteConflict) GetConflictCommitTs() uint64 { if m != nil { return m.ConflictCommitTs } return 0 } type AlreadyExist struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AlreadyExist) Reset() { *m = AlreadyExist{} } func (m *AlreadyExist) String() string { return proto.CompactTextString(m) } func (*AlreadyExist) ProtoMessage() {} func (*AlreadyExist) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{74} } func (m *AlreadyExist) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AlreadyExist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AlreadyExist.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AlreadyExist) XXX_Merge(src proto.Message) { xxx_messageInfo_AlreadyExist.Merge(dst, src) } func (m *AlreadyExist) XXX_Size() int { return m.Size() } func (m *AlreadyExist) XXX_DiscardUnknown() { xxx_messageInfo_AlreadyExist.DiscardUnknown(m) } var xxx_messageInfo_AlreadyExist proto.InternalMessageInfo func (m *AlreadyExist) GetKey() []byte { if m != nil { return m.Key } return nil } type Deadlock struct { LockTs uint64 `protobuf:"varint,1,opt,name=lock_ts,json=lockTs,proto3" json:"lock_ts,omitempty"` LockKey []byte `protobuf:"bytes,2,opt,name=lock_key,json=lockKey,proto3" json:"lock_key,omitempty"` DeadlockKeyHash uint64 `protobuf:"varint,3,opt,name=deadlock_key_hash,json=deadlockKeyHash,proto3" json:"deadlock_key_hash,omitempty"` WaitChain []*deadlock.WaitForEntry `protobuf:"bytes,4,rep,name=wait_chain,json=waitChain" json:"wait_chain,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Deadlock) Reset() { *m = Deadlock{} } func (m *Deadlock) String() string { return proto.CompactTextString(m) } func (*Deadlock) ProtoMessage() {} func (*Deadlock) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{75} } func (m *Deadlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Deadlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Deadlock.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Deadlock) XXX_Merge(src proto.Message) { xxx_messageInfo_Deadlock.Merge(dst, src) } func (m *Deadlock) XXX_Size() int { return m.Size() } func (m *Deadlock) XXX_DiscardUnknown() { xxx_messageInfo_Deadlock.DiscardUnknown(m) } var xxx_messageInfo_Deadlock proto.InternalMessageInfo func (m *Deadlock) GetLockTs() uint64 { if m != nil { return m.LockTs } return 0 } func (m *Deadlock) GetLockKey() []byte { if m != nil { return m.LockKey } return nil } func (m *Deadlock) GetDeadlockKeyHash() uint64 { if m != nil { return m.DeadlockKeyHash } return 0 } func (m *Deadlock) GetWaitChain() []*deadlock.WaitForEntry { if m != nil { return m.WaitChain } return nil } type CommitTsExpired struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` AttemptedCommitTs uint64 `protobuf:"varint,2,opt,name=attempted_commit_ts,json=attemptedCommitTs,proto3" json:"attempted_commit_ts,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` MinCommitTs uint64 `protobuf:"varint,4,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitTsExpired) Reset() { *m = CommitTsExpired{} } func (m *CommitTsExpired) String() string { return proto.CompactTextString(m) } func (*CommitTsExpired) ProtoMessage() {} func (*CommitTsExpired) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{76} } func (m *CommitTsExpired) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitTsExpired) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitTsExpired.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitTsExpired) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitTsExpired.Merge(dst, src) } func (m *CommitTsExpired) XXX_Size() int { return m.Size() } func (m *CommitTsExpired) XXX_DiscardUnknown() { xxx_messageInfo_CommitTsExpired.DiscardUnknown(m) } var xxx_messageInfo_CommitTsExpired proto.InternalMessageInfo func (m *CommitTsExpired) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *CommitTsExpired) GetAttemptedCommitTs() uint64 { if m != nil { return m.AttemptedCommitTs } return 0 } func (m *CommitTsExpired) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *CommitTsExpired) GetMinCommitTs() uint64 { if m != nil { return m.MinCommitTs } return 0 } type TxnNotFound struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` PrimaryKey []byte `protobuf:"bytes,2,opt,name=primary_key,json=primaryKey,proto3" json:"primary_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnNotFound) Reset() { *m = TxnNotFound{} } func (m *TxnNotFound) String() string { return proto.CompactTextString(m) } func (*TxnNotFound) ProtoMessage() {} func (*TxnNotFound) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{77} } func (m *TxnNotFound) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnNotFound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnNotFound.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnNotFound) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnNotFound.Merge(dst, src) } func (m *TxnNotFound) XXX_Size() int { return m.Size() } func (m *TxnNotFound) XXX_DiscardUnknown() { xxx_messageInfo_TxnNotFound.DiscardUnknown(m) } var xxx_messageInfo_TxnNotFound proto.InternalMessageInfo func (m *TxnNotFound) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *TxnNotFound) GetPrimaryKey() []byte { if m != nil { return m.PrimaryKey } return nil } type CommitTsTooLarge struct { CommitTs uint64 `protobuf:"varint,1,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitTsTooLarge) Reset() { *m = CommitTsTooLarge{} } func (m *CommitTsTooLarge) String() string { return proto.CompactTextString(m) } func (*CommitTsTooLarge) ProtoMessage() {} func (*CommitTsTooLarge) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{78} } func (m *CommitTsTooLarge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitTsTooLarge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitTsTooLarge.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitTsTooLarge) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitTsTooLarge.Merge(dst, src) } func (m *CommitTsTooLarge) XXX_Size() int { return m.Size() } func (m *CommitTsTooLarge) XXX_DiscardUnknown() { xxx_messageInfo_CommitTsTooLarge.DiscardUnknown(m) } var xxx_messageInfo_CommitTsTooLarge proto.InternalMessageInfo func (m *CommitTsTooLarge) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } type AssertionFailed struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Assertion Assertion `protobuf:"varint,3,opt,name=assertion,proto3,enum=kvrpcpb.Assertion" json:"assertion,omitempty"` ExistingStartTs uint64 `protobuf:"varint,4,opt,name=existing_start_ts,json=existingStartTs,proto3" json:"existing_start_ts,omitempty"` ExistingCommitTs uint64 `protobuf:"varint,5,opt,name=existing_commit_ts,json=existingCommitTs,proto3" json:"existing_commit_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AssertionFailed) Reset() { *m = AssertionFailed{} } func (m *AssertionFailed) String() string { return proto.CompactTextString(m) } func (*AssertionFailed) ProtoMessage() {} func (*AssertionFailed) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{79} } func (m *AssertionFailed) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AssertionFailed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AssertionFailed.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AssertionFailed) XXX_Merge(src proto.Message) { xxx_messageInfo_AssertionFailed.Merge(dst, src) } func (m *AssertionFailed) XXX_Size() int { return m.Size() } func (m *AssertionFailed) XXX_DiscardUnknown() { xxx_messageInfo_AssertionFailed.DiscardUnknown(m) } var xxx_messageInfo_AssertionFailed proto.InternalMessageInfo func (m *AssertionFailed) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *AssertionFailed) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *AssertionFailed) GetAssertion() Assertion { if m != nil { return m.Assertion } return Assertion_None } func (m *AssertionFailed) GetExistingStartTs() uint64 { if m != nil { return m.ExistingStartTs } return 0 } func (m *AssertionFailed) GetExistingCommitTs() uint64 { if m != nil { return m.ExistingCommitTs } return 0 } type TimeDetail struct { // Off-cpu wall time elapsed in TiKV side. Usually this includes queue waiting time and // other kind of waitings in series. WaitWallTimeMs int64 `protobuf:"varint,1,opt,name=wait_wall_time_ms,json=waitWallTimeMs,proto3" json:"wait_wall_time_ms,omitempty"` // Off-cpu and on-cpu wall time elapsed to actually process the request payload. It does not // include `wait_wall_time`. // This field is very close to the CPU time in most cases. Some wait time spend in RocksDB // cannot be excluded for now, like Mutex wait time, which is included in this field, so that // this field is called wall time instead of CPU time. ProcessWallTimeMs int64 `protobuf:"varint,2,opt,name=process_wall_time_ms,json=processWallTimeMs,proto3" json:"process_wall_time_ms,omitempty"` // KV read wall Time means the time used in key/value scan and get. KvReadWallTimeMs int64 `protobuf:"varint,3,opt,name=kv_read_wall_time_ms,json=kvReadWallTimeMs,proto3" json:"kv_read_wall_time_ms,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TimeDetail) Reset() { *m = TimeDetail{} } func (m *TimeDetail) String() string { return proto.CompactTextString(m) } func (*TimeDetail) ProtoMessage() {} func (*TimeDetail) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{80} } func (m *TimeDetail) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TimeDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TimeDetail.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TimeDetail) XXX_Merge(src proto.Message) { xxx_messageInfo_TimeDetail.Merge(dst, src) } func (m *TimeDetail) XXX_Size() int { return m.Size() } func (m *TimeDetail) XXX_DiscardUnknown() { xxx_messageInfo_TimeDetail.DiscardUnknown(m) } var xxx_messageInfo_TimeDetail proto.InternalMessageInfo func (m *TimeDetail) GetWaitWallTimeMs() int64 { if m != nil { return m.WaitWallTimeMs } return 0 } func (m *TimeDetail) GetProcessWallTimeMs() int64 { if m != nil { return m.ProcessWallTimeMs } return 0 } func (m *TimeDetail) GetKvReadWallTimeMs() int64 { if m != nil { return m.KvReadWallTimeMs } return 0 } type ScanInfo struct { Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` Processed int64 `protobuf:"varint,2,opt,name=processed,proto3" json:"processed,omitempty"` ReadBytes int64 `protobuf:"varint,3,opt,name=read_bytes,json=readBytes,proto3" json:"read_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanInfo) Reset() { *m = ScanInfo{} } func (m *ScanInfo) String() string { return proto.CompactTextString(m) } func (*ScanInfo) ProtoMessage() {} func (*ScanInfo) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{81} } func (m *ScanInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanInfo.Merge(dst, src) } func (m *ScanInfo) XXX_Size() int { return m.Size() } func (m *ScanInfo) XXX_DiscardUnknown() { xxx_messageInfo_ScanInfo.DiscardUnknown(m) } var xxx_messageInfo_ScanInfo proto.InternalMessageInfo func (m *ScanInfo) GetTotal() int64 { if m != nil { return m.Total } return 0 } func (m *ScanInfo) GetProcessed() int64 { if m != nil { return m.Processed } return 0 } func (m *ScanInfo) GetReadBytes() int64 { if m != nil { return m.ReadBytes } return 0 } // Only reserved for compatibility. type ScanDetail struct { Write *ScanInfo `protobuf:"bytes,1,opt,name=write" json:"write,omitempty"` Lock *ScanInfo `protobuf:"bytes,2,opt,name=lock" json:"lock,omitempty"` Data *ScanInfo `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanDetail) Reset() { *m = ScanDetail{} } func (m *ScanDetail) String() string { return proto.CompactTextString(m) } func (*ScanDetail) ProtoMessage() {} func (*ScanDetail) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{82} } func (m *ScanDetail) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanDetail.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanDetail) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanDetail.Merge(dst, src) } func (m *ScanDetail) XXX_Size() int { return m.Size() } func (m *ScanDetail) XXX_DiscardUnknown() { xxx_messageInfo_ScanDetail.DiscardUnknown(m) } var xxx_messageInfo_ScanDetail proto.InternalMessageInfo func (m *ScanDetail) GetWrite() *ScanInfo { if m != nil { return m.Write } return nil } func (m *ScanDetail) GetLock() *ScanInfo { if m != nil { return m.Lock } return nil } func (m *ScanDetail) GetData() *ScanInfo { if m != nil { return m.Data } return nil } type ScanDetailV2 struct { // Number of user keys scanned from the storage. // It does not include deleted version or RocksDB tombstone keys. // For Coprocessor requests, it includes keys that has been filtered out by // Selection. ProcessedVersions uint64 `protobuf:"varint,1,opt,name=processed_versions,json=processedVersions,proto3" json:"processed_versions,omitempty"` // Number of bytes of user key-value pairs scanned from the storage, i.e. // total size of data returned from MVCC layer. ProcessedVersionsSize uint64 `protobuf:"varint,8,opt,name=processed_versions_size,json=processedVersionsSize,proto3" json:"processed_versions_size,omitempty"` // Approximate number of MVCC keys meet during scanning. It includes // deleted versions, but does not include RocksDB tombstone keys. // // When this field is notably larger than `processed_versions`, it means // there are a lot of deleted MVCC keys. TotalVersions uint64 `protobuf:"varint,2,opt,name=total_versions,json=totalVersions,proto3" json:"total_versions,omitempty"` // Total number of deletes and single deletes skipped over during // iteration, i.e. how many RocksDB tombstones are skipped. RocksdbDeleteSkippedCount uint64 `protobuf:"varint,3,opt,name=rocksdb_delete_skipped_count,json=rocksdbDeleteSkippedCount,proto3" json:"rocksdb_delete_skipped_count,omitempty"` // Total number of internal keys skipped over during iteration. // See https://github.com/facebook/rocksdb/blob/9f1c84ca471d8b1ad7be9f3eebfc2c7e07dfd7a7/include/rocksdb/perf_context.h#L84 for details. RocksdbKeySkippedCount uint64 `protobuf:"varint,4,opt,name=rocksdb_key_skipped_count,json=rocksdbKeySkippedCount,proto3" json:"rocksdb_key_skipped_count,omitempty"` // Total number of RocksDB block cache hits. RocksdbBlockCacheHitCount uint64 `protobuf:"varint,5,opt,name=rocksdb_block_cache_hit_count,json=rocksdbBlockCacheHitCount,proto3" json:"rocksdb_block_cache_hit_count,omitempty"` // Total number of block reads (with IO). RocksdbBlockReadCount uint64 `protobuf:"varint,6,opt,name=rocksdb_block_read_count,json=rocksdbBlockReadCount,proto3" json:"rocksdb_block_read_count,omitempty"` // Total number of bytes from block reads. RocksdbBlockReadByte uint64 `protobuf:"varint,7,opt,name=rocksdb_block_read_byte,json=rocksdbBlockReadByte,proto3" json:"rocksdb_block_read_byte,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanDetailV2) Reset() { *m = ScanDetailV2{} } func (m *ScanDetailV2) String() string { return proto.CompactTextString(m) } func (*ScanDetailV2) ProtoMessage() {} func (*ScanDetailV2) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{83} } func (m *ScanDetailV2) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanDetailV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanDetailV2.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanDetailV2) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanDetailV2.Merge(dst, src) } func (m *ScanDetailV2) XXX_Size() int { return m.Size() } func (m *ScanDetailV2) XXX_DiscardUnknown() { xxx_messageInfo_ScanDetailV2.DiscardUnknown(m) } var xxx_messageInfo_ScanDetailV2 proto.InternalMessageInfo func (m *ScanDetailV2) GetProcessedVersions() uint64 { if m != nil { return m.ProcessedVersions } return 0 } func (m *ScanDetailV2) GetProcessedVersionsSize() uint64 { if m != nil { return m.ProcessedVersionsSize } return 0 } func (m *ScanDetailV2) GetTotalVersions() uint64 { if m != nil { return m.TotalVersions } return 0 } func (m *ScanDetailV2) GetRocksdbDeleteSkippedCount() uint64 { if m != nil { return m.RocksdbDeleteSkippedCount } return 0 } func (m *ScanDetailV2) GetRocksdbKeySkippedCount() uint64 { if m != nil { return m.RocksdbKeySkippedCount } return 0 } func (m *ScanDetailV2) GetRocksdbBlockCacheHitCount() uint64 { if m != nil { return m.RocksdbBlockCacheHitCount } return 0 } func (m *ScanDetailV2) GetRocksdbBlockReadCount() uint64 { if m != nil { return m.RocksdbBlockReadCount } return 0 } func (m *ScanDetailV2) GetRocksdbBlockReadByte() uint64 { if m != nil { return m.RocksdbBlockReadByte } return 0 } type ExecDetails struct { // Available when ctx.record_time_stat = true or meet slow query. TimeDetail *TimeDetail `protobuf:"bytes,1,opt,name=time_detail,json=timeDetail" json:"time_detail,omitempty"` // Available when ctx.record_scan_stat = true or meet slow query. ScanDetail *ScanDetail `protobuf:"bytes,2,opt,name=scan_detail,json=scanDetail" json:"scan_detail,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecDetails) Reset() { *m = ExecDetails{} } func (m *ExecDetails) String() string { return proto.CompactTextString(m) } func (*ExecDetails) ProtoMessage() {} func (*ExecDetails) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{84} } func (m *ExecDetails) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecDetails.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExecDetails) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecDetails.Merge(dst, src) } func (m *ExecDetails) XXX_Size() int { return m.Size() } func (m *ExecDetails) XXX_DiscardUnknown() { xxx_messageInfo_ExecDetails.DiscardUnknown(m) } var xxx_messageInfo_ExecDetails proto.InternalMessageInfo func (m *ExecDetails) GetTimeDetail() *TimeDetail { if m != nil { return m.TimeDetail } return nil } func (m *ExecDetails) GetScanDetail() *ScanDetail { if m != nil { return m.ScanDetail } return nil } type ExecDetailsV2 struct { // Available when ctx.record_time_stat = true or meet slow query. TimeDetail *TimeDetail `protobuf:"bytes,1,opt,name=time_detail,json=timeDetail" json:"time_detail,omitempty"` // Available when ctx.record_scan_stat = true or meet slow query. ScanDetailV2 *ScanDetailV2 `protobuf:"bytes,2,opt,name=scan_detail_v2,json=scanDetailV2" json:"scan_detail_v2,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecDetailsV2) Reset() { *m = ExecDetailsV2{} } func (m *ExecDetailsV2) String() string { return proto.CompactTextString(m) } func (*ExecDetailsV2) ProtoMessage() {} func (*ExecDetailsV2) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{85} } func (m *ExecDetailsV2) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecDetailsV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecDetailsV2.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExecDetailsV2) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecDetailsV2.Merge(dst, src) } func (m *ExecDetailsV2) XXX_Size() int { return m.Size() } func (m *ExecDetailsV2) XXX_DiscardUnknown() { xxx_messageInfo_ExecDetailsV2.DiscardUnknown(m) } var xxx_messageInfo_ExecDetailsV2 proto.InternalMessageInfo func (m *ExecDetailsV2) GetTimeDetail() *TimeDetail { if m != nil { return m.TimeDetail } return nil } func (m *ExecDetailsV2) GetScanDetailV2() *ScanDetailV2 { if m != nil { return m.ScanDetailV2 } return nil } type KvPair struct { Error *KeyError `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KvPair) Reset() { *m = KvPair{} } func (m *KvPair) String() string { return proto.CompactTextString(m) } func (*KvPair) ProtoMessage() {} func (*KvPair) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{86} } func (m *KvPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KvPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KvPair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KvPair) XXX_Merge(src proto.Message) { xxx_messageInfo_KvPair.Merge(dst, src) } func (m *KvPair) XXX_Size() int { return m.Size() } func (m *KvPair) XXX_DiscardUnknown() { xxx_messageInfo_KvPair.DiscardUnknown(m) } var xxx_messageInfo_KvPair proto.InternalMessageInfo func (m *KvPair) GetError() *KeyError { if m != nil { return m.Error } return nil } func (m *KvPair) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *KvPair) GetValue() []byte { if m != nil { return m.Value } return nil } type Mutation struct { Op Op `protobuf:"varint,1,opt,name=op,proto3,enum=kvrpcpb.Op" json:"op,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` Assertion Assertion `protobuf:"varint,4,opt,name=assertion,proto3,enum=kvrpcpb.Assertion" json:"assertion,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Mutation) Reset() { *m = Mutation{} } func (m *Mutation) String() string { return proto.CompactTextString(m) } func (*Mutation) ProtoMessage() {} func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{87} } func (m *Mutation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Mutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Mutation.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Mutation) XXX_Merge(src proto.Message) { xxx_messageInfo_Mutation.Merge(dst, src) } func (m *Mutation) XXX_Size() int { return m.Size() } func (m *Mutation) XXX_DiscardUnknown() { xxx_messageInfo_Mutation.DiscardUnknown(m) } var xxx_messageInfo_Mutation proto.InternalMessageInfo func (m *Mutation) GetOp() Op { if m != nil { return m.Op } return Op_Put } func (m *Mutation) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *Mutation) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *Mutation) GetAssertion() Assertion { if m != nil { return m.Assertion } return Assertion_None } type MvccWrite struct { Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` HasOverlappedRollback bool `protobuf:"varint,5,opt,name=has_overlapped_rollback,json=hasOverlappedRollback,proto3" json:"has_overlapped_rollback,omitempty"` HasGcFence bool `protobuf:"varint,6,opt,name=has_gc_fence,json=hasGcFence,proto3" json:"has_gc_fence,omitempty"` GcFence uint64 `protobuf:"varint,7,opt,name=gc_fence,json=gcFence,proto3" json:"gc_fence,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccWrite) Reset() { *m = MvccWrite{} } func (m *MvccWrite) String() string { return proto.CompactTextString(m) } func (*MvccWrite) ProtoMessage() {} func (*MvccWrite) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{88} } func (m *MvccWrite) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccWrite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccWrite.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccWrite) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccWrite.Merge(dst, src) } func (m *MvccWrite) XXX_Size() int { return m.Size() } func (m *MvccWrite) XXX_DiscardUnknown() { xxx_messageInfo_MvccWrite.DiscardUnknown(m) } var xxx_messageInfo_MvccWrite proto.InternalMessageInfo func (m *MvccWrite) GetType() Op { if m != nil { return m.Type } return Op_Put } func (m *MvccWrite) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *MvccWrite) GetCommitTs() uint64 { if m != nil { return m.CommitTs } return 0 } func (m *MvccWrite) GetShortValue() []byte { if m != nil { return m.ShortValue } return nil } func (m *MvccWrite) GetHasOverlappedRollback() bool { if m != nil { return m.HasOverlappedRollback } return false } func (m *MvccWrite) GetHasGcFence() bool { if m != nil { return m.HasGcFence } return false } func (m *MvccWrite) GetGcFence() uint64 { if m != nil { return m.GcFence } return 0 } type MvccValue struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccValue) Reset() { *m = MvccValue{} } func (m *MvccValue) String() string { return proto.CompactTextString(m) } func (*MvccValue) ProtoMessage() {} func (*MvccValue) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{89} } func (m *MvccValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccValue.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccValue) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccValue.Merge(dst, src) } func (m *MvccValue) XXX_Size() int { return m.Size() } func (m *MvccValue) XXX_DiscardUnknown() { xxx_messageInfo_MvccValue.DiscardUnknown(m) } var xxx_messageInfo_MvccValue proto.InternalMessageInfo func (m *MvccValue) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *MvccValue) GetValue() []byte { if m != nil { return m.Value } return nil } type MvccLock struct { Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` Primary []byte `protobuf:"bytes,3,opt,name=primary,proto3" json:"primary,omitempty"` ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` Ttl uint64 `protobuf:"varint,5,opt,name=ttl,proto3" json:"ttl,omitempty"` ForUpdateTs uint64 `protobuf:"varint,6,opt,name=for_update_ts,json=forUpdateTs,proto3" json:"for_update_ts,omitempty"` TxnSize uint64 `protobuf:"varint,7,opt,name=txn_size,json=txnSize,proto3" json:"txn_size,omitempty"` UseAsyncCommit bool `protobuf:"varint,8,opt,name=use_async_commit,json=useAsyncCommit,proto3" json:"use_async_commit,omitempty"` Secondaries [][]byte `protobuf:"bytes,9,rep,name=secondaries" json:"secondaries,omitempty"` RollbackTs []uint64 `protobuf:"varint,10,rep,packed,name=rollback_ts,json=rollbackTs" json:"rollback_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccLock) Reset() { *m = MvccLock{} } func (m *MvccLock) String() string { return proto.CompactTextString(m) } func (*MvccLock) ProtoMessage() {} func (*MvccLock) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{90} } func (m *MvccLock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccLock.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccLock) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccLock.Merge(dst, src) } func (m *MvccLock) XXX_Size() int { return m.Size() } func (m *MvccLock) XXX_DiscardUnknown() { xxx_messageInfo_MvccLock.DiscardUnknown(m) } var xxx_messageInfo_MvccLock proto.InternalMessageInfo func (m *MvccLock) GetType() Op { if m != nil { return m.Type } return Op_Put } func (m *MvccLock) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *MvccLock) GetPrimary() []byte { if m != nil { return m.Primary } return nil } func (m *MvccLock) GetShortValue() []byte { if m != nil { return m.ShortValue } return nil } func (m *MvccLock) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } func (m *MvccLock) GetForUpdateTs() uint64 { if m != nil { return m.ForUpdateTs } return 0 } func (m *MvccLock) GetTxnSize() uint64 { if m != nil { return m.TxnSize } return 0 } func (m *MvccLock) GetUseAsyncCommit() bool { if m != nil { return m.UseAsyncCommit } return false } func (m *MvccLock) GetSecondaries() [][]byte { if m != nil { return m.Secondaries } return nil } func (m *MvccLock) GetRollbackTs() []uint64 { if m != nil { return m.RollbackTs } return nil } type MvccInfo struct { Lock *MvccLock `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"` Writes []*MvccWrite `protobuf:"bytes,2,rep,name=writes" json:"writes,omitempty"` Values []*MvccValue `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MvccInfo) Reset() { *m = MvccInfo{} } func (m *MvccInfo) String() string { return proto.CompactTextString(m) } func (*MvccInfo) ProtoMessage() {} func (*MvccInfo) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{91} } func (m *MvccInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MvccInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MvccInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MvccInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_MvccInfo.Merge(dst, src) } func (m *MvccInfo) XXX_Size() int { return m.Size() } func (m *MvccInfo) XXX_DiscardUnknown() { xxx_messageInfo_MvccInfo.DiscardUnknown(m) } var xxx_messageInfo_MvccInfo proto.InternalMessageInfo func (m *MvccInfo) GetLock() *MvccLock { if m != nil { return m.Lock } return nil } func (m *MvccInfo) GetWrites() []*MvccWrite { if m != nil { return m.Writes } return nil } func (m *MvccInfo) GetValues() []*MvccValue { if m != nil { return m.Values } return nil } type TxnInfo struct { Txn uint64 `protobuf:"varint,1,opt,name=txn,proto3" json:"txn,omitempty"` Status uint64 `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TxnInfo) Reset() { *m = TxnInfo{} } func (m *TxnInfo) String() string { return proto.CompactTextString(m) } func (*TxnInfo) ProtoMessage() {} func (*TxnInfo) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{92} } func (m *TxnInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TxnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TxnInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TxnInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_TxnInfo.Merge(dst, src) } func (m *TxnInfo) XXX_Size() int { return m.Size() } func (m *TxnInfo) XXX_DiscardUnknown() { xxx_messageInfo_TxnInfo.DiscardUnknown(m) } var xxx_messageInfo_TxnInfo proto.InternalMessageInfo func (m *TxnInfo) GetTxn() uint64 { if m != nil { return m.Txn } return 0 } func (m *TxnInfo) GetStatus() uint64 { if m != nil { return m.Status } return 0 } type KeyRange struct { StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyRange) Reset() { *m = KeyRange{} } func (m *KeyRange) String() string { return proto.CompactTextString(m) } func (*KeyRange) ProtoMessage() {} func (*KeyRange) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{93} } func (m *KeyRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyRange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyRange) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyRange.Merge(dst, src) } func (m *KeyRange) XXX_Size() int { return m.Size() } func (m *KeyRange) XXX_DiscardUnknown() { xxx_messageInfo_KeyRange.DiscardUnknown(m) } var xxx_messageInfo_KeyRange proto.InternalMessageInfo func (m *KeyRange) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *KeyRange) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } type LeaderInfo struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` PeerId uint64 `protobuf:"varint,2,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"` Term uint64 `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,4,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` ReadState *ReadState `protobuf:"bytes,5,opt,name=read_state,json=readState" json:"read_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LeaderInfo) Reset() { *m = LeaderInfo{} } func (m *LeaderInfo) String() string { return proto.CompactTextString(m) } func (*LeaderInfo) ProtoMessage() {} func (*LeaderInfo) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{94} } func (m *LeaderInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LeaderInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LeaderInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LeaderInfo) XXX_Merge(src proto.Message) { xxx_messageInfo_LeaderInfo.Merge(dst, src) } func (m *LeaderInfo) XXX_Size() int { return m.Size() } func (m *LeaderInfo) XXX_DiscardUnknown() { xxx_messageInfo_LeaderInfo.DiscardUnknown(m) } var xxx_messageInfo_LeaderInfo proto.InternalMessageInfo func (m *LeaderInfo) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *LeaderInfo) GetPeerId() uint64 { if m != nil { return m.PeerId } return 0 } func (m *LeaderInfo) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *LeaderInfo) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *LeaderInfo) GetReadState() *ReadState { if m != nil { return m.ReadState } return nil } type ReadState struct { AppliedIndex uint64 `protobuf:"varint,1,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` SafeTs uint64 `protobuf:"varint,2,opt,name=safe_ts,json=safeTs,proto3" json:"safe_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadState) Reset() { *m = ReadState{} } func (m *ReadState) String() string { return proto.CompactTextString(m) } func (*ReadState) ProtoMessage() {} func (*ReadState) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{95} } func (m *ReadState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadState) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadState.Merge(dst, src) } func (m *ReadState) XXX_Size() int { return m.Size() } func (m *ReadState) XXX_DiscardUnknown() { xxx_messageInfo_ReadState.DiscardUnknown(m) } var xxx_messageInfo_ReadState proto.InternalMessageInfo func (m *ReadState) GetAppliedIndex() uint64 { if m != nil { return m.AppliedIndex } return 0 } func (m *ReadState) GetSafeTs() uint64 { if m != nil { return m.SafeTs } return 0 } type CheckLeaderRequest struct { Regions []*LeaderInfo `protobuf:"bytes,1,rep,name=regions" json:"regions,omitempty"` Ts uint64 `protobuf:"varint,2,opt,name=ts,proto3" json:"ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckLeaderRequest) Reset() { *m = CheckLeaderRequest{} } func (m *CheckLeaderRequest) String() string { return proto.CompactTextString(m) } func (*CheckLeaderRequest) ProtoMessage() {} func (*CheckLeaderRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{96} } func (m *CheckLeaderRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckLeaderRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckLeaderRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckLeaderRequest.Merge(dst, src) } func (m *CheckLeaderRequest) XXX_Size() int { return m.Size() } func (m *CheckLeaderRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckLeaderRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckLeaderRequest proto.InternalMessageInfo func (m *CheckLeaderRequest) GetRegions() []*LeaderInfo { if m != nil { return m.Regions } return nil } func (m *CheckLeaderRequest) GetTs() uint64 { if m != nil { return m.Ts } return 0 } type CheckLeaderResponse struct { Regions []uint64 `protobuf:"varint,1,rep,packed,name=regions" json:"regions,omitempty"` Ts uint64 `protobuf:"varint,2,opt,name=ts,proto3" json:"ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckLeaderResponse) Reset() { *m = CheckLeaderResponse{} } func (m *CheckLeaderResponse) String() string { return proto.CompactTextString(m) } func (*CheckLeaderResponse) ProtoMessage() {} func (*CheckLeaderResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{97} } func (m *CheckLeaderResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckLeaderResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CheckLeaderResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckLeaderResponse.Merge(dst, src) } func (m *CheckLeaderResponse) XXX_Size() int { return m.Size() } func (m *CheckLeaderResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckLeaderResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckLeaderResponse proto.InternalMessageInfo func (m *CheckLeaderResponse) GetRegions() []uint64 { if m != nil { return m.Regions } return nil } func (m *CheckLeaderResponse) GetTs() uint64 { if m != nil { return m.Ts } return 0 } type StoreSafeTSRequest struct { // Get the minimal `safe_ts` from regions that overlap with the key range [`start_key`, `end_key`) // An empty key range means all regions in the store KeyRange *KeyRange `protobuf:"bytes,1,opt,name=key_range,json=keyRange" json:"key_range,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreSafeTSRequest) Reset() { *m = StoreSafeTSRequest{} } func (m *StoreSafeTSRequest) String() string { return proto.CompactTextString(m) } func (*StoreSafeTSRequest) ProtoMessage() {} func (*StoreSafeTSRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{98} } func (m *StoreSafeTSRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreSafeTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreSafeTSRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreSafeTSRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreSafeTSRequest.Merge(dst, src) } func (m *StoreSafeTSRequest) XXX_Size() int { return m.Size() } func (m *StoreSafeTSRequest) XXX_DiscardUnknown() { xxx_messageInfo_StoreSafeTSRequest.DiscardUnknown(m) } var xxx_messageInfo_StoreSafeTSRequest proto.InternalMessageInfo func (m *StoreSafeTSRequest) GetKeyRange() *KeyRange { if m != nil { return m.KeyRange } return nil } type StoreSafeTSResponse struct { SafeTs uint64 `protobuf:"varint,1,opt,name=safe_ts,json=safeTs,proto3" json:"safe_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreSafeTSResponse) Reset() { *m = StoreSafeTSResponse{} } func (m *StoreSafeTSResponse) String() string { return proto.CompactTextString(m) } func (*StoreSafeTSResponse) ProtoMessage() {} func (*StoreSafeTSResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{99} } func (m *StoreSafeTSResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreSafeTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreSafeTSResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreSafeTSResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreSafeTSResponse.Merge(dst, src) } func (m *StoreSafeTSResponse) XXX_Size() int { return m.Size() } func (m *StoreSafeTSResponse) XXX_DiscardUnknown() { xxx_messageInfo_StoreSafeTSResponse.DiscardUnknown(m) } var xxx_messageInfo_StoreSafeTSResponse proto.InternalMessageInfo func (m *StoreSafeTSResponse) GetSafeTs() uint64 { if m != nil { return m.SafeTs } return 0 } type RawGetKeyTTLRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawGetKeyTTLRequest) Reset() { *m = RawGetKeyTTLRequest{} } func (m *RawGetKeyTTLRequest) String() string { return proto.CompactTextString(m) } func (*RawGetKeyTTLRequest) ProtoMessage() {} func (*RawGetKeyTTLRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{100} } func (m *RawGetKeyTTLRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawGetKeyTTLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawGetKeyTTLRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawGetKeyTTLRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawGetKeyTTLRequest.Merge(dst, src) } func (m *RawGetKeyTTLRequest) XXX_Size() int { return m.Size() } func (m *RawGetKeyTTLRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawGetKeyTTLRequest.DiscardUnknown(m) } var xxx_messageInfo_RawGetKeyTTLRequest proto.InternalMessageInfo func (m *RawGetKeyTTLRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawGetKeyTTLRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *RawGetKeyTTLRequest) GetCf() string { if m != nil { return m.Cf } return "" } type RawGetKeyTTLResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Ttl uint64 `protobuf:"varint,3,opt,name=ttl,proto3" json:"ttl,omitempty"` NotFound bool `protobuf:"varint,4,opt,name=not_found,json=notFound,proto3" json:"not_found,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawGetKeyTTLResponse) Reset() { *m = RawGetKeyTTLResponse{} } func (m *RawGetKeyTTLResponse) String() string { return proto.CompactTextString(m) } func (*RawGetKeyTTLResponse) ProtoMessage() {} func (*RawGetKeyTTLResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{101} } func (m *RawGetKeyTTLResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawGetKeyTTLResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawGetKeyTTLResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawGetKeyTTLResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawGetKeyTTLResponse.Merge(dst, src) } func (m *RawGetKeyTTLResponse) XXX_Size() int { return m.Size() } func (m *RawGetKeyTTLResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawGetKeyTTLResponse.DiscardUnknown(m) } var xxx_messageInfo_RawGetKeyTTLResponse proto.InternalMessageInfo func (m *RawGetKeyTTLResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawGetKeyTTLResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *RawGetKeyTTLResponse) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } func (m *RawGetKeyTTLResponse) GetNotFound() bool { if m != nil { return m.NotFound } return false } type RawCASRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` PreviousNotExist bool `protobuf:"varint,4,opt,name=previous_not_exist,json=previousNotExist,proto3" json:"previous_not_exist,omitempty"` PreviousValue []byte `protobuf:"bytes,5,opt,name=previous_value,json=previousValue,proto3" json:"previous_value,omitempty"` Cf string `protobuf:"bytes,6,opt,name=cf,proto3" json:"cf,omitempty"` Ttl uint64 `protobuf:"varint,7,opt,name=ttl,proto3" json:"ttl,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawCASRequest) Reset() { *m = RawCASRequest{} } func (m *RawCASRequest) String() string { return proto.CompactTextString(m) } func (*RawCASRequest) ProtoMessage() {} func (*RawCASRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{102} } func (m *RawCASRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawCASRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawCASRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawCASRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawCASRequest.Merge(dst, src) } func (m *RawCASRequest) XXX_Size() int { return m.Size() } func (m *RawCASRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawCASRequest.DiscardUnknown(m) } var xxx_messageInfo_RawCASRequest proto.InternalMessageInfo func (m *RawCASRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawCASRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *RawCASRequest) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *RawCASRequest) GetPreviousNotExist() bool { if m != nil { return m.PreviousNotExist } return false } func (m *RawCASRequest) GetPreviousValue() []byte { if m != nil { return m.PreviousValue } return nil } func (m *RawCASRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *RawCASRequest) GetTtl() uint64 { if m != nil { return m.Ttl } return 0 } type RawCASResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Succeed bool `protobuf:"varint,3,opt,name=succeed,proto3" json:"succeed,omitempty"` // The previous value regardless of whether the comparison is succeed. PreviousNotExist bool `protobuf:"varint,4,opt,name=previous_not_exist,json=previousNotExist,proto3" json:"previous_not_exist,omitempty"` PreviousValue []byte `protobuf:"bytes,5,opt,name=previous_value,json=previousValue,proto3" json:"previous_value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawCASResponse) Reset() { *m = RawCASResponse{} } func (m *RawCASResponse) String() string { return proto.CompactTextString(m) } func (*RawCASResponse) ProtoMessage() {} func (*RawCASResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{103} } func (m *RawCASResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawCASResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawCASResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawCASResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawCASResponse.Merge(dst, src) } func (m *RawCASResponse) XXX_Size() int { return m.Size() } func (m *RawCASResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawCASResponse.DiscardUnknown(m) } var xxx_messageInfo_RawCASResponse proto.InternalMessageInfo func (m *RawCASResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawCASResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *RawCASResponse) GetSucceed() bool { if m != nil { return m.Succeed } return false } func (m *RawCASResponse) GetPreviousNotExist() bool { if m != nil { return m.PreviousNotExist } return false } func (m *RawCASResponse) GetPreviousValue() []byte { if m != nil { return m.PreviousValue } return nil } type GetLockWaitInfoRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetLockWaitInfoRequest) Reset() { *m = GetLockWaitInfoRequest{} } func (m *GetLockWaitInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetLockWaitInfoRequest) ProtoMessage() {} func (*GetLockWaitInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{104} } func (m *GetLockWaitInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetLockWaitInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetLockWaitInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetLockWaitInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetLockWaitInfoRequest.Merge(dst, src) } func (m *GetLockWaitInfoRequest) XXX_Size() int { return m.Size() } func (m *GetLockWaitInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetLockWaitInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_GetLockWaitInfoRequest proto.InternalMessageInfo func (m *GetLockWaitInfoRequest) GetContext() *Context { if m != nil { return m.Context } return nil } type GetLockWaitInfoResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Entries []*deadlock.WaitForEntry `protobuf:"bytes,3,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetLockWaitInfoResponse) Reset() { *m = GetLockWaitInfoResponse{} } func (m *GetLockWaitInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetLockWaitInfoResponse) ProtoMessage() {} func (*GetLockWaitInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{105} } func (m *GetLockWaitInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetLockWaitInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetLockWaitInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetLockWaitInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetLockWaitInfoResponse.Merge(dst, src) } func (m *GetLockWaitInfoResponse) XXX_Size() int { return m.Size() } func (m *GetLockWaitInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetLockWaitInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_GetLockWaitInfoResponse proto.InternalMessageInfo func (m *GetLockWaitInfoResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *GetLockWaitInfoResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *GetLockWaitInfoResponse) GetEntries() []*deadlock.WaitForEntry { if m != nil { return m.Entries } return nil } type RawCoprocessorRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` CoprName string `protobuf:"bytes,2,opt,name=copr_name,json=coprName,proto3" json:"copr_name,omitempty"` // Coprorcessor version constraint following SEMVER definition. CoprVersionReq string `protobuf:"bytes,3,opt,name=copr_version_req,json=coprVersionReq,proto3" json:"copr_version_req,omitempty"` Ranges []*KeyRange `protobuf:"bytes,4,rep,name=ranges" json:"ranges,omitempty"` Data []byte `protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawCoprocessorRequest) Reset() { *m = RawCoprocessorRequest{} } func (m *RawCoprocessorRequest) String() string { return proto.CompactTextString(m) } func (*RawCoprocessorRequest) ProtoMessage() {} func (*RawCoprocessorRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{106} } func (m *RawCoprocessorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawCoprocessorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawCoprocessorRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawCoprocessorRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawCoprocessorRequest.Merge(dst, src) } func (m *RawCoprocessorRequest) XXX_Size() int { return m.Size() } func (m *RawCoprocessorRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawCoprocessorRequest.DiscardUnknown(m) } var xxx_messageInfo_RawCoprocessorRequest proto.InternalMessageInfo func (m *RawCoprocessorRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawCoprocessorRequest) GetCoprName() string { if m != nil { return m.CoprName } return "" } func (m *RawCoprocessorRequest) GetCoprVersionReq() string { if m != nil { return m.CoprVersionReq } return "" } func (m *RawCoprocessorRequest) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } func (m *RawCoprocessorRequest) GetData() []byte { if m != nil { return m.Data } return nil } type RawCoprocessorResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` // Error message for cases like if no coprocessor with a matching name is found // or on a version mismatch between plugin_api and the coprocessor. Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawCoprocessorResponse) Reset() { *m = RawCoprocessorResponse{} } func (m *RawCoprocessorResponse) String() string { return proto.CompactTextString(m) } func (*RawCoprocessorResponse) ProtoMessage() {} func (*RawCoprocessorResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{107} } func (m *RawCoprocessorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawCoprocessorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawCoprocessorResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawCoprocessorResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawCoprocessorResponse.Merge(dst, src) } func (m *RawCoprocessorResponse) XXX_Size() int { return m.Size() } func (m *RawCoprocessorResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawCoprocessorResponse.DiscardUnknown(m) } var xxx_messageInfo_RawCoprocessorResponse proto.InternalMessageInfo func (m *RawCoprocessorResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawCoprocessorResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *RawCoprocessorResponse) GetData() []byte { if m != nil { return m.Data } return nil } type RawChecksumRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Algorithm ChecksumAlgorithm `protobuf:"varint,2,opt,name=algorithm,proto3,enum=kvrpcpb.ChecksumAlgorithm" json:"algorithm,omitempty"` Ranges []*KeyRange `protobuf:"bytes,3,rep,name=ranges" json:"ranges,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawChecksumRequest) Reset() { *m = RawChecksumRequest{} } func (m *RawChecksumRequest) String() string { return proto.CompactTextString(m) } func (*RawChecksumRequest) ProtoMessage() {} func (*RawChecksumRequest) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{108} } func (m *RawChecksumRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawChecksumRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawChecksumRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawChecksumRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RawChecksumRequest.Merge(dst, src) } func (m *RawChecksumRequest) XXX_Size() int { return m.Size() } func (m *RawChecksumRequest) XXX_DiscardUnknown() { xxx_messageInfo_RawChecksumRequest.DiscardUnknown(m) } var xxx_messageInfo_RawChecksumRequest proto.InternalMessageInfo func (m *RawChecksumRequest) GetContext() *Context { if m != nil { return m.Context } return nil } func (m *RawChecksumRequest) GetAlgorithm() ChecksumAlgorithm { if m != nil { return m.Algorithm } return ChecksumAlgorithm_Crc64_Xor } func (m *RawChecksumRequest) GetRanges() []*KeyRange { if m != nil { return m.Ranges } return nil } type RawChecksumResponse struct { RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` Checksum uint64 `protobuf:"varint,3,opt,name=checksum,proto3" json:"checksum,omitempty"` TotalKvs uint64 `protobuf:"varint,4,opt,name=total_kvs,json=totalKvs,proto3" json:"total_kvs,omitempty"` TotalBytes uint64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RawChecksumResponse) Reset() { *m = RawChecksumResponse{} } func (m *RawChecksumResponse) String() string { return proto.CompactTextString(m) } func (*RawChecksumResponse) ProtoMessage() {} func (*RawChecksumResponse) Descriptor() ([]byte, []int) { return fileDescriptor_kvrpcpb_44115b53ffa2eeab, []int{109} } func (m *RawChecksumResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RawChecksumResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RawChecksumResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RawChecksumResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RawChecksumResponse.Merge(dst, src) } func (m *RawChecksumResponse) XXX_Size() int { return m.Size() } func (m *RawChecksumResponse) XXX_DiscardUnknown() { xxx_messageInfo_RawChecksumResponse.DiscardUnknown(m) } var xxx_messageInfo_RawChecksumResponse proto.InternalMessageInfo func (m *RawChecksumResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError } return nil } func (m *RawChecksumResponse) GetError() string { if m != nil { return m.Error } return "" } func (m *RawChecksumResponse) GetChecksum() uint64 { if m != nil { return m.Checksum } return 0 } func (m *RawChecksumResponse) GetTotalKvs() uint64 { if m != nil { return m.TotalKvs } return 0 } func (m *RawChecksumResponse) GetTotalBytes() uint64 { if m != nil { return m.TotalBytes } return 0 } func init() { proto.RegisterType((*GetRequest)(nil), "kvrpcpb.GetRequest") proto.RegisterType((*GetResponse)(nil), "kvrpcpb.GetResponse") proto.RegisterType((*ScanRequest)(nil), "kvrpcpb.ScanRequest") proto.RegisterType((*ScanResponse)(nil), "kvrpcpb.ScanResponse") proto.RegisterType((*PrewriteRequest)(nil), "kvrpcpb.PrewriteRequest") proto.RegisterType((*PrewriteResponse)(nil), "kvrpcpb.PrewriteResponse") proto.RegisterType((*PessimisticLockRequest)(nil), "kvrpcpb.PessimisticLockRequest") proto.RegisterType((*PessimisticLockResponse)(nil), "kvrpcpb.PessimisticLockResponse") proto.RegisterType((*PessimisticRollbackRequest)(nil), "kvrpcpb.PessimisticRollbackRequest") proto.RegisterType((*PessimisticRollbackResponse)(nil), "kvrpcpb.PessimisticRollbackResponse") proto.RegisterType((*TxnHeartBeatRequest)(nil), "kvrpcpb.TxnHeartBeatRequest") proto.RegisterType((*TxnHeartBeatResponse)(nil), "kvrpcpb.TxnHeartBeatResponse") proto.RegisterType((*CheckTxnStatusRequest)(nil), "kvrpcpb.CheckTxnStatusRequest") proto.RegisterType((*CheckTxnStatusResponse)(nil), "kvrpcpb.CheckTxnStatusResponse") proto.RegisterType((*CheckSecondaryLocksRequest)(nil), "kvrpcpb.CheckSecondaryLocksRequest") proto.RegisterType((*CheckSecondaryLocksResponse)(nil), "kvrpcpb.CheckSecondaryLocksResponse") proto.RegisterType((*CommitRequest)(nil), "kvrpcpb.CommitRequest") proto.RegisterType((*CommitResponse)(nil), "kvrpcpb.CommitResponse") proto.RegisterType((*ImportRequest)(nil), "kvrpcpb.ImportRequest") proto.RegisterType((*ImportResponse)(nil), "kvrpcpb.ImportResponse") proto.RegisterType((*CleanupRequest)(nil), "kvrpcpb.CleanupRequest") proto.RegisterType((*CleanupResponse)(nil), "kvrpcpb.CleanupResponse") proto.RegisterType((*BatchGetRequest)(nil), "kvrpcpb.BatchGetRequest") proto.RegisterType((*BatchGetResponse)(nil), "kvrpcpb.BatchGetResponse") proto.RegisterType((*BatchRollbackRequest)(nil), "kvrpcpb.BatchRollbackRequest") proto.RegisterType((*BatchRollbackResponse)(nil), "kvrpcpb.BatchRollbackResponse") proto.RegisterType((*ScanLockRequest)(nil), "kvrpcpb.ScanLockRequest") proto.RegisterType((*ScanLockResponse)(nil), "kvrpcpb.ScanLockResponse") proto.RegisterType((*ResolveLockRequest)(nil), "kvrpcpb.ResolveLockRequest") proto.RegisterType((*ResolveLockResponse)(nil), "kvrpcpb.ResolveLockResponse") proto.RegisterType((*GCRequest)(nil), "kvrpcpb.GCRequest") proto.RegisterType((*GCResponse)(nil), "kvrpcpb.GCResponse") proto.RegisterType((*DeleteRangeRequest)(nil), "kvrpcpb.DeleteRangeRequest") proto.RegisterType((*DeleteRangeResponse)(nil), "kvrpcpb.DeleteRangeResponse") proto.RegisterType((*RawGetRequest)(nil), "kvrpcpb.RawGetRequest") proto.RegisterType((*RawGetResponse)(nil), "kvrpcpb.RawGetResponse") proto.RegisterType((*RawBatchGetRequest)(nil), "kvrpcpb.RawBatchGetRequest") proto.RegisterType((*RawBatchGetResponse)(nil), "kvrpcpb.RawBatchGetResponse") proto.RegisterType((*RawPutRequest)(nil), "kvrpcpb.RawPutRequest") proto.RegisterType((*RawPutResponse)(nil), "kvrpcpb.RawPutResponse") proto.RegisterType((*RawBatchPutRequest)(nil), "kvrpcpb.RawBatchPutRequest") proto.RegisterType((*RawBatchPutResponse)(nil), "kvrpcpb.RawBatchPutResponse") proto.RegisterType((*RawDeleteRequest)(nil), "kvrpcpb.RawDeleteRequest") proto.RegisterType((*RawDeleteResponse)(nil), "kvrpcpb.RawDeleteResponse") proto.RegisterType((*RawBatchDeleteRequest)(nil), "kvrpcpb.RawBatchDeleteRequest") proto.RegisterType((*RawBatchDeleteResponse)(nil), "kvrpcpb.RawBatchDeleteResponse") proto.RegisterType((*RawScanRequest)(nil), "kvrpcpb.RawScanRequest") proto.RegisterType((*RawScanResponse)(nil), "kvrpcpb.RawScanResponse") proto.RegisterType((*RawDeleteRangeRequest)(nil), "kvrpcpb.RawDeleteRangeRequest") proto.RegisterType((*RawDeleteRangeResponse)(nil), "kvrpcpb.RawDeleteRangeResponse") proto.RegisterType((*RawBatchScanRequest)(nil), "kvrpcpb.RawBatchScanRequest") proto.RegisterType((*RawBatchScanResponse)(nil), "kvrpcpb.RawBatchScanResponse") proto.RegisterType((*UnsafeDestroyRangeRequest)(nil), "kvrpcpb.UnsafeDestroyRangeRequest") proto.RegisterType((*UnsafeDestroyRangeResponse)(nil), "kvrpcpb.UnsafeDestroyRangeResponse") proto.RegisterType((*RegisterLockObserverRequest)(nil), "kvrpcpb.RegisterLockObserverRequest") proto.RegisterType((*RegisterLockObserverResponse)(nil), "kvrpcpb.RegisterLockObserverResponse") proto.RegisterType((*CheckLockObserverRequest)(nil), "kvrpcpb.CheckLockObserverRequest") proto.RegisterType((*CheckLockObserverResponse)(nil), "kvrpcpb.CheckLockObserverResponse") proto.RegisterType((*RemoveLockObserverRequest)(nil), "kvrpcpb.RemoveLockObserverRequest") proto.RegisterType((*RemoveLockObserverResponse)(nil), "kvrpcpb.RemoveLockObserverResponse") proto.RegisterType((*PhysicalScanLockRequest)(nil), "kvrpcpb.PhysicalScanLockRequest") proto.RegisterType((*PhysicalScanLockResponse)(nil), "kvrpcpb.PhysicalScanLockResponse") proto.RegisterType((*SplitRegionRequest)(nil), "kvrpcpb.SplitRegionRequest") proto.RegisterType((*SplitRegionResponse)(nil), "kvrpcpb.SplitRegionResponse") proto.RegisterType((*ReadIndexRequest)(nil), "kvrpcpb.ReadIndexRequest") proto.RegisterType((*ReadIndexResponse)(nil), "kvrpcpb.ReadIndexResponse") proto.RegisterType((*MvccGetByKeyRequest)(nil), "kvrpcpb.MvccGetByKeyRequest") proto.RegisterType((*MvccGetByKeyResponse)(nil), "kvrpcpb.MvccGetByKeyResponse") proto.RegisterType((*MvccGetByStartTsRequest)(nil), "kvrpcpb.MvccGetByStartTsRequest") proto.RegisterType((*MvccGetByStartTsResponse)(nil), "kvrpcpb.MvccGetByStartTsResponse") proto.RegisterType((*Context)(nil), "kvrpcpb.Context") proto.RegisterType((*LockInfo)(nil), "kvrpcpb.LockInfo") proto.RegisterType((*KeyError)(nil), "kvrpcpb.KeyError") proto.RegisterType((*WriteConflict)(nil), "kvrpcpb.WriteConflict") proto.RegisterType((*AlreadyExist)(nil), "kvrpcpb.AlreadyExist") proto.RegisterType((*Deadlock)(nil), "kvrpcpb.Deadlock") proto.RegisterType((*CommitTsExpired)(nil), "kvrpcpb.CommitTsExpired") proto.RegisterType((*TxnNotFound)(nil), "kvrpcpb.TxnNotFound") proto.RegisterType((*CommitTsTooLarge)(nil), "kvrpcpb.CommitTsTooLarge") proto.RegisterType((*AssertionFailed)(nil), "kvrpcpb.AssertionFailed") proto.RegisterType((*TimeDetail)(nil), "kvrpcpb.TimeDetail") proto.RegisterType((*ScanInfo)(nil), "kvrpcpb.ScanInfo") proto.RegisterType((*ScanDetail)(nil), "kvrpcpb.ScanDetail") proto.RegisterType((*ScanDetailV2)(nil), "kvrpcpb.ScanDetailV2") proto.RegisterType((*ExecDetails)(nil), "kvrpcpb.ExecDetails") proto.RegisterType((*ExecDetailsV2)(nil), "kvrpcpb.ExecDetailsV2") proto.RegisterType((*KvPair)(nil), "kvrpcpb.KvPair") proto.RegisterType((*Mutation)(nil), "kvrpcpb.Mutation") proto.RegisterType((*MvccWrite)(nil), "kvrpcpb.MvccWrite") proto.RegisterType((*MvccValue)(nil), "kvrpcpb.MvccValue") proto.RegisterType((*MvccLock)(nil), "kvrpcpb.MvccLock") proto.RegisterType((*MvccInfo)(nil), "kvrpcpb.MvccInfo") proto.RegisterType((*TxnInfo)(nil), "kvrpcpb.TxnInfo") proto.RegisterType((*KeyRange)(nil), "kvrpcpb.KeyRange") proto.RegisterType((*LeaderInfo)(nil), "kvrpcpb.LeaderInfo") proto.RegisterType((*ReadState)(nil), "kvrpcpb.ReadState") proto.RegisterType((*CheckLeaderRequest)(nil), "kvrpcpb.CheckLeaderRequest") proto.RegisterType((*CheckLeaderResponse)(nil), "kvrpcpb.CheckLeaderResponse") proto.RegisterType((*StoreSafeTSRequest)(nil), "kvrpcpb.StoreSafeTSRequest") proto.RegisterType((*StoreSafeTSResponse)(nil), "kvrpcpb.StoreSafeTSResponse") proto.RegisterType((*RawGetKeyTTLRequest)(nil), "kvrpcpb.RawGetKeyTTLRequest") proto.RegisterType((*RawGetKeyTTLResponse)(nil), "kvrpcpb.RawGetKeyTTLResponse") proto.RegisterType((*RawCASRequest)(nil), "kvrpcpb.RawCASRequest") proto.RegisterType((*RawCASResponse)(nil), "kvrpcpb.RawCASResponse") proto.RegisterType((*GetLockWaitInfoRequest)(nil), "kvrpcpb.GetLockWaitInfoRequest") proto.RegisterType((*GetLockWaitInfoResponse)(nil), "kvrpcpb.GetLockWaitInfoResponse") proto.RegisterType((*RawCoprocessorRequest)(nil), "kvrpcpb.RawCoprocessorRequest") proto.RegisterType((*RawCoprocessorResponse)(nil), "kvrpcpb.RawCoprocessorResponse") proto.RegisterType((*RawChecksumRequest)(nil), "kvrpcpb.RawChecksumRequest") proto.RegisterType((*RawChecksumResponse)(nil), "kvrpcpb.RawChecksumResponse") proto.RegisterEnum("kvrpcpb.APIVersion", APIVersion_name, APIVersion_value) proto.RegisterEnum("kvrpcpb.CommandPri", CommandPri_name, CommandPri_value) proto.RegisterEnum("kvrpcpb.IsolationLevel", IsolationLevel_name, IsolationLevel_value) proto.RegisterEnum("kvrpcpb.DiskFullOpt", DiskFullOpt_name, DiskFullOpt_value) proto.RegisterEnum("kvrpcpb.Op", Op_name, Op_value) proto.RegisterEnum("kvrpcpb.Assertion", Assertion_name, Assertion_value) proto.RegisterEnum("kvrpcpb.AssertionLevel", AssertionLevel_name, AssertionLevel_value) proto.RegisterEnum("kvrpcpb.Action", Action_name, Action_value) proto.RegisterEnum("kvrpcpb.ExtraOp", ExtraOp_name, ExtraOp_value) proto.RegisterEnum("kvrpcpb.ChecksumAlgorithm", ChecksumAlgorithm_name, ChecksumAlgorithm_value) } func (m *GetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n1, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Version != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Version)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n2, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n3, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.NotFound { dAtA[i] = 0x20 i++ if m.NotFound { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ExecDetailsV2 != nil { dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ExecDetailsV2.Size())) n4, err := m.ExecDetailsV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n5, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if m.Limit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit)) } if m.Version != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Version)) } if m.KeyOnly { dAtA[i] = 0x28 i++ if m.KeyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.Reverse { dAtA[i] = 0x30 i++ if m.Reverse { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.EndKey) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.SampleStep != 0 { dAtA[i] = 0x40 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.SampleStep)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n6, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Error != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n7, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrewriteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrewriteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n8, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if len(m.Mutations) > 0 { for _, msg := range m.Mutations { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PrimaryLock) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryLock))) i += copy(dAtA[i:], m.PrimaryLock) } if m.StartVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.LockTtl != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } if m.SkipConstraintCheck { dAtA[i] = 0x30 i++ if m.SkipConstraintCheck { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.IsPessimisticLock) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.IsPessimisticLock))) for _, b := range m.IsPessimisticLock { if b { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } } if m.TxnSize != 0 { dAtA[i] = 0x40 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TxnSize)) } if m.ForUpdateTs != 0 { dAtA[i] = 0x48 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ForUpdateTs)) } if m.MinCommitTs != 0 { dAtA[i] = 0x50 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MinCommitTs)) } if m.UseAsyncCommit { dAtA[i] = 0x58 i++ if m.UseAsyncCommit { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { dAtA[i] = 0x62 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.TryOnePc { dAtA[i] = 0x68 i++ if m.TryOnePc { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.MaxCommitTs != 0 { dAtA[i] = 0x70 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxCommitTs)) } if m.AssertionLevel != 0 { dAtA[i] = 0x78 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AssertionLevel)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrewriteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrewriteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n9, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if len(m.Errors) > 0 { for _, msg := range m.Errors { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.MinCommitTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MinCommitTs)) } if m.OnePcCommitTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.OnePcCommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PessimisticLockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PessimisticLockRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n10, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if len(m.Mutations) > 0 { for _, msg := range m.Mutations { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PrimaryLock) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryLock))) i += copy(dAtA[i:], m.PrimaryLock) } if m.StartVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.LockTtl != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } if m.ForUpdateTs != 0 { dAtA[i] = 0x30 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ForUpdateTs)) } if m.IsFirstLock { dAtA[i] = 0x38 i++ if m.IsFirstLock { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.WaitTimeout != 0 { dAtA[i] = 0x40 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.WaitTimeout)) } if m.Force { dAtA[i] = 0x48 i++ if m.Force { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ReturnValues { dAtA[i] = 0x50 i++ if m.ReturnValues { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.MinCommitTs != 0 { dAtA[i] = 0x58 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MinCommitTs)) } if m.CheckExistence { dAtA[i] = 0x60 i++ if m.CheckExistence { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PessimisticLockResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PessimisticLockResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n11, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if len(m.Errors) > 0 { for _, msg := range m.Errors { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.CommitTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs)) } if len(m.Value) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if len(m.Values) > 0 { for _, b := range m.Values { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if len(m.NotFounds) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.NotFounds))) for _, b := range m.NotFounds { if b { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PessimisticRollbackRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PessimisticRollbackRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n12, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.StartVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.ForUpdateTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ForUpdateTs)) } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PessimisticRollbackResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PessimisticRollbackResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n13, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if len(m.Errors) > 0 { for _, msg := range m.Errors { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnHeartBeatRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnHeartBeatRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n14, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if len(m.PrimaryLock) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryLock))) i += copy(dAtA[i:], m.PrimaryLock) } if m.StartVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.AdviseLockTtl != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AdviseLockTtl)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnHeartBeatResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnHeartBeatResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n15, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n16, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if m.LockTtl != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckTxnStatusRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckTxnStatusRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n17, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if len(m.PrimaryKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryKey))) i += copy(dAtA[i:], m.PrimaryKey) } if m.LockTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTs)) } if m.CallerStartTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CallerStartTs)) } if m.CurrentTs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CurrentTs)) } if m.RollbackIfNotExist { dAtA[i] = 0x30 i++ if m.RollbackIfNotExist { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ForceSyncCommit { dAtA[i] = 0x38 i++ if m.ForceSyncCommit { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ResolvingPessimisticLock { dAtA[i] = 0x40 i++ if m.ResolvingPessimisticLock { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckTxnStatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckTxnStatusResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n18, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n19, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if m.LockTtl != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } if m.CommitVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if m.Action != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Action)) } if m.LockInfo != nil { dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockInfo.Size())) n20, err := m.LockInfo.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckSecondaryLocksRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckSecondaryLocksRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n21, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.StartVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckSecondaryLocksResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckSecondaryLocksResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n22, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n23, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 } if len(m.Locks) > 0 { for _, msg := range m.Locks { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.CommitTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n24, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n24 } if m.StartVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.CommitVersion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n25, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n26, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } if m.CommitVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ImportRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Mutations) > 0 { for _, msg := range m.Mutations { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.CommitVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ImportResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ImportResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n27, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CleanupRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CleanupRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n28, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n28 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.StartVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.CurrentTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CurrentTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CleanupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CleanupResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n29, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n29 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n30, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n30 } if m.CommitVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchGetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchGetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n31, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n31 } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.Version != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Version)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchGetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchGetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n32, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n32 } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.ExecDetailsV2 != nil { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ExecDetailsV2.Size())) n33, err := m.ExecDetailsV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n33 } if m.Error != nil { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n34, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n34 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchRollbackRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchRollbackRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n35, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n35 } if m.StartVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchRollbackResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchRollbackResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n36, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n36 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n37, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n37 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanLockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanLockRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n38, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n38 } if m.MaxVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxVersion)) } if len(m.StartKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if m.Limit != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit)) } if len(m.EndKey) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanLockResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanLockResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n39, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n39 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n40, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n40 } if len(m.Locks) > 0 { for _, msg := range m.Locks { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResolveLockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveLockRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n41, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n41 } if m.StartVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } if m.CommitVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } if len(m.TxnInfos) > 0 { for _, msg := range m.TxnInfos { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResolveLockResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResolveLockResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n42, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n42 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n43, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n43 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GCRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GCRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n44, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n44 } if m.SafePoint != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GCResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GCResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n45, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n45 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n46, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n46 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n47, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n47 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.NotifyOnly { dAtA[i] = 0x20 i++ if m.NotifyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n48, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n48 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawGetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawGetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n49, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n49 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawGetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawGetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n50, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n50 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.NotFound { dAtA[i] = 0x20 i++ if m.NotFound { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchGetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchGetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n51, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n51 } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchGetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchGetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n52, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n52 } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawPutRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawPutRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n53, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n53 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if len(m.Cf) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Ttl != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ttl)) } if m.ForCas { dAtA[i] = 0x30 i++ if m.ForCas { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawPutResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawPutResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n54, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n54 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchPutRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchPutRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n55, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n55 } if len(m.Pairs) > 0 { for _, msg := range m.Pairs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Ttl != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ttl)) } if m.ForCas { dAtA[i] = 0x28 i++ if m.ForCas { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Ttls) > 0 { dAtA57 := make([]byte, len(m.Ttls)*10) var j56 int for _, num := range m.Ttls { for num >= 1<<7 { dAtA57[j56] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j56++ } dAtA57[j56] = uint8(num) j56++ } dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(j56)) i += copy(dAtA[i:], dAtA57[:j56]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchPutResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchPutResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n58, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n58 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawDeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawDeleteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n59, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n59 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.ForCas { dAtA[i] = 0x20 i++ if m.ForCas { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawDeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawDeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n60, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n60 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchDeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchDeleteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n61, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n61 } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.ForCas { dAtA[i] = 0x20 i++ if m.ForCas { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchDeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchDeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n62, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n62 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawScanRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawScanRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n63, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n63 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if m.Limit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit)) } if m.KeyOnly { dAtA[i] = 0x20 i++ if m.KeyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Cf) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Reverse { dAtA[i] = 0x30 i++ if m.Reverse { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.EndKey) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawScanResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawScanResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n64, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n64 } if len(m.Kvs) > 0 { for _, msg := range m.Kvs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawDeleteRangeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawDeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n65, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n65 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if len(m.Cf) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawDeleteRangeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawDeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n66, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n66 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchScanRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchScanRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n67, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n67 } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.EachLimit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.EachLimit)) } if m.KeyOnly { dAtA[i] = 0x20 i++ if m.KeyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Cf) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Reverse { dAtA[i] = 0x30 i++ if m.Reverse { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawBatchScanResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawBatchScanResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n68, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n68 } if len(m.Kvs) > 0 { for _, msg := range m.Kvs { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UnsafeDestroyRangeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeDestroyRangeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n69, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n69 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UnsafeDestroyRangeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeDestroyRangeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n70, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n70 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegisterLockObserverRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegisterLockObserverRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n71, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n71 } if m.MaxTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegisterLockObserverResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegisterLockObserverResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Error) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckLockObserverRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckLockObserverRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n72, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n72 } if m.MaxTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckLockObserverResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckLockObserverResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Error) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.IsClean { dAtA[i] = 0x10 i++ if m.IsClean { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Locks) > 0 { for _, msg := range m.Locks { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RemoveLockObserverRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RemoveLockObserverRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n73, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n73 } if m.MaxTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RemoveLockObserverResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RemoveLockObserverResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Error) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PhysicalScanLockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PhysicalScanLockRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n74, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n74 } if m.MaxTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxTs)) } if len(m.StartKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if m.Limit != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PhysicalScanLockResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PhysicalScanLockResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Error) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if len(m.Locks) > 0 { for _, msg := range m.Locks { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRegionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRegionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n75, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n75 } if len(m.SplitKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.SplitKey))) i += copy(dAtA[i:], m.SplitKey) } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.IsRawKv { dAtA[i] = 0x20 i++ if m.IsRawKv { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRegionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRegionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n76, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n76 } if m.Left != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Left.Size())) n77, err := m.Left.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n77 } if m.Right != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Right.Size())) n78, err := m.Right.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n78 } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadIndexRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadIndexRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n79, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n79 } if m.StartTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadIndexResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadIndexResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n80, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n80 } if m.ReadIndex != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ReadIndex)) } if m.Locked != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Locked.Size())) n81, err := m.Locked.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n81 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccGetByKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccGetByKeyRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n82, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n82 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccGetByKeyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n83, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n83 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.Info != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size())) n84, err := m.Info.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n84 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccGetByStartTsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccGetByStartTsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n85, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n85 } if m.StartTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccGetByStartTsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccGetByStartTsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n86, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n86 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if len(m.Key) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Info != nil { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Info.Size())) n87, err := m.Info.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n87 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Context) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Context) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionId)) } if m.RegionEpoch != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionEpoch.Size())) n88, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n88 } if m.Peer != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Peer.Size())) n89, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n89 } if m.Term != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Term)) } if m.Priority != 0 { dAtA[i] = 0x30 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Priority)) } if m.IsolationLevel != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.IsolationLevel)) } if m.NotFillCache { dAtA[i] = 0x40 i++ if m.NotFillCache { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.SyncLog { dAtA[i] = 0x48 i++ if m.SyncLog { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.RecordTimeStat { dAtA[i] = 0x50 i++ if m.RecordTimeStat { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.RecordScanStat { dAtA[i] = 0x58 i++ if m.RecordScanStat { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ReplicaRead { dAtA[i] = 0x60 i++ if m.ReplicaRead { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.ResolvedLocks) > 0 { dAtA91 := make([]byte, len(m.ResolvedLocks)*10) var j90 int for _, num := range m.ResolvedLocks { for num >= 1<<7 { dAtA91[j90] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j90++ } dAtA91[j90] = uint8(num) j90++ } dAtA[i] = 0x6a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(j90)) i += copy(dAtA[i:], dAtA91[:j90]) } if m.MaxExecutionDurationMs != 0 { dAtA[i] = 0x70 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MaxExecutionDurationMs)) } if m.AppliedIndex != 0 { dAtA[i] = 0x78 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AppliedIndex)) } if m.TaskId != 0 { dAtA[i] = 0x80 i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TaskId)) } if m.StaleRead { dAtA[i] = 0x88 i++ dAtA[i] = 0x1 i++ if m.StaleRead { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.ResourceGroupTag) > 0 { dAtA[i] = 0x92 i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ResourceGroupTag))) i += copy(dAtA[i:], m.ResourceGroupTag) } if m.DiskFullOpt != 0 { dAtA[i] = 0x98 i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.DiskFullOpt)) } if m.IsRetryRequest { dAtA[i] = 0xa0 i++ dAtA[i] = 0x1 i++ if m.IsRetryRequest { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ApiVersion != 0 { dAtA[i] = 0xa8 i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ApiVersion)) } if len(m.CommittedLocks) > 0 { dAtA93 := make([]byte, len(m.CommittedLocks)*10) var j92 int for _, num := range m.CommittedLocks { for num >= 1<<7 { dAtA93[j92] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j92++ } dAtA93[j92] = uint8(num) j92++ } dAtA[i] = 0xb2 i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(j92)) i += copy(dAtA[i:], dAtA93[:j92]) } if m.TraceContext != nil { dAtA[i] = 0xba i++ dAtA[i] = 0x1 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TraceContext.Size())) n94, err := m.TraceContext.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n94 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LockInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LockInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.PrimaryLock) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryLock))) i += copy(dAtA[i:], m.PrimaryLock) } if m.LockVersion != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockVersion)) } if len(m.Key) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.LockTtl != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } if m.TxnSize != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TxnSize)) } if m.LockType != 0 { dAtA[i] = 0x30 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockType)) } if m.LockForUpdateTs != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockForUpdateTs)) } if m.UseAsyncCommit { dAtA[i] = 0x40 i++ if m.UseAsyncCommit { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.MinCommitTs != 0 { dAtA[i] = 0x48 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MinCommitTs)) } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { dAtA[i] = 0x52 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KeyError) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyError) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Locked != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Locked.Size())) n95, err := m.Locked.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n95 } if len(m.Retryable) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Retryable))) i += copy(dAtA[i:], m.Retryable) } if len(m.Abort) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Abort))) i += copy(dAtA[i:], m.Abort) } if m.Conflict != nil { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Conflict.Size())) n96, err := m.Conflict.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n96 } if m.AlreadyExist != nil { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AlreadyExist.Size())) n97, err := m.AlreadyExist.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n97 } if m.Deadlock != nil { dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Deadlock.Size())) n98, err := m.Deadlock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n98 } if m.CommitTsExpired != nil { dAtA[i] = 0x3a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTsExpired.Size())) n99, err := m.CommitTsExpired.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n99 } if m.TxnNotFound != nil { dAtA[i] = 0x42 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TxnNotFound.Size())) n100, err := m.TxnNotFound.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n100 } if m.CommitTsTooLarge != nil { dAtA[i] = 0x4a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTsTooLarge.Size())) n101, err := m.CommitTsTooLarge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n101 } if m.AssertionFailed != nil { dAtA[i] = 0x52 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AssertionFailed.Size())) n102, err := m.AssertionFailed.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n102 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WriteConflict) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WriteConflict) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if m.ConflictTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ConflictTs)) } if len(m.Key) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Primary) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Primary))) i += copy(dAtA[i:], m.Primary) } if m.ConflictCommitTs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ConflictCommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AlreadyExist) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AlreadyExist) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Deadlock) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Deadlock) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.LockTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTs)) } if len(m.LockKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.LockKey))) i += copy(dAtA[i:], m.LockKey) } if m.DeadlockKeyHash != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.DeadlockKeyHash)) } if len(m.WaitChain) > 0 { for _, msg := range m.WaitChain { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitTsExpired) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitTsExpired) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if m.AttemptedCommitTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AttemptedCommitTs)) } if len(m.Key) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.MinCommitTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.MinCommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnNotFound) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnNotFound) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if len(m.PrimaryKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PrimaryKey))) i += copy(dAtA[i:], m.PrimaryKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitTsTooLarge) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitTsTooLarge) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CommitTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AssertionFailed) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AssertionFailed) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Assertion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Assertion)) } if m.ExistingStartTs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ExistingStartTs)) } if m.ExistingCommitTs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ExistingCommitTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TimeDetail) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TimeDetail) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.WaitWallTimeMs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.WaitWallTimeMs)) } if m.ProcessWallTimeMs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ProcessWallTimeMs)) } if m.KvReadWallTimeMs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.KvReadWallTimeMs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Total != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Total)) } if m.Processed != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Processed)) } if m.ReadBytes != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ReadBytes)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanDetail) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanDetail) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Write != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Write.Size())) n103, err := m.Write.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n103 } if m.Lock != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Lock.Size())) n104, err := m.Lock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n104 } if m.Data != nil { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Data.Size())) n105, err := m.Data.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n105 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanDetailV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanDetailV2) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ProcessedVersions != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ProcessedVersions)) } if m.TotalVersions != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TotalVersions)) } if m.RocksdbDeleteSkippedCount != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RocksdbDeleteSkippedCount)) } if m.RocksdbKeySkippedCount != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RocksdbKeySkippedCount)) } if m.RocksdbBlockCacheHitCount != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RocksdbBlockCacheHitCount)) } if m.RocksdbBlockReadCount != 0 { dAtA[i] = 0x30 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RocksdbBlockReadCount)) } if m.RocksdbBlockReadByte != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RocksdbBlockReadByte)) } if m.ProcessedVersionsSize != 0 { dAtA[i] = 0x40 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ProcessedVersionsSize)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExecDetails) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExecDetails) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TimeDetail != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TimeDetail.Size())) n106, err := m.TimeDetail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n106 } if m.ScanDetail != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ScanDetail.Size())) n107, err := m.ScanDetail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n107 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExecDetailsV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExecDetailsV2) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TimeDetail != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TimeDetail.Size())) n108, err := m.TimeDetail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n108 } if m.ScanDetailV2 != nil { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ScanDetailV2.Size())) n109, err := m.ScanDetailV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n109 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KvPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KvPair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Error.Size())) n110, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n110 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Mutation) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Mutation) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Op != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Op)) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.Assertion != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Assertion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccWrite) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccWrite) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Type != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Type)) } if m.StartTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if m.CommitTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitTs)) } if len(m.ShortValue) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue))) i += copy(dAtA[i:], m.ShortValue) } if m.HasOverlappedRollback { dAtA[i] = 0x28 i++ if m.HasOverlappedRollback { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.HasGcFence { dAtA[i] = 0x30 i++ if m.HasGcFence { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.GcFence != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.GcFence)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccValue) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccValue) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccLock) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccLock) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Type != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Type)) } if m.StartTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } if len(m.Primary) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Primary))) i += copy(dAtA[i:], m.Primary) } if len(m.ShortValue) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue))) i += copy(dAtA[i:], m.ShortValue) } if m.Ttl != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ttl)) } if m.ForUpdateTs != 0 { dAtA[i] = 0x30 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ForUpdateTs)) } if m.TxnSize != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TxnSize)) } if m.UseAsyncCommit { dAtA[i] = 0x40 i++ if m.UseAsyncCommit { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { dAtA[i] = 0x4a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if len(m.RollbackTs) > 0 { dAtA112 := make([]byte, len(m.RollbackTs)*10) var j111 int for _, num := range m.RollbackTs { for num >= 1<<7 { dAtA112[j111] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j111++ } dAtA112[j111] = uint8(num) j111++ } dAtA[i] = 0x52 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(j111)) i += copy(dAtA[i:], dAtA112[:j111]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MvccInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MvccInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Lock != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Lock.Size())) n113, err := m.Lock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n113 } if len(m.Writes) > 0 { for _, msg := range m.Writes { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Values) > 0 { for _, msg := range m.Values { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TxnInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TxnInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Txn != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Txn)) } if m.Status != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Status)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KeyRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyRange) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.StartKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LeaderInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LeaderInfo) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionId)) } if m.PeerId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.PeerId)) } if m.Term != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Term)) } if m.RegionEpoch != nil { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionEpoch.Size())) n114, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n114 } if m.ReadState != nil { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ReadState.Size())) n115, err := m.ReadState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n115 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.AppliedIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.AppliedIndex)) } if m.SafeTs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckLeaderRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckLeaderRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Ts != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ts)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CheckLeaderResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CheckLeaderResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Regions) > 0 { dAtA117 := make([]byte, len(m.Regions)*10) var j116 int for _, num := range m.Regions { for num >= 1<<7 { dAtA117[j116] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j116++ } dAtA117[j116] = uint8(num) j116++ } dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(j116)) i += copy(dAtA[i:], dAtA117[:j116]) } if m.Ts != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ts)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreSafeTSRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreSafeTSRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.KeyRange != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.KeyRange.Size())) n118, err := m.KeyRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n118 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreSafeTSResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreSafeTSResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.SafeTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawGetKeyTTLRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawGetKeyTTLRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n119, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n119 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Cf) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawGetKeyTTLResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawGetKeyTTLResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n120, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n120 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.Ttl != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ttl)) } if m.NotFound { dAtA[i] = 0x20 i++ if m.NotFound { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawCASRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawCASRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n121, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n121 } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.PreviousNotExist { dAtA[i] = 0x20 i++ if m.PreviousNotExist { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.PreviousValue) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PreviousValue))) i += copy(dAtA[i:], m.PreviousValue) } if len(m.Cf) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Ttl != 0 { dAtA[i] = 0x38 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Ttl)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawCASResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawCASResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n122, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n122 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.Succeed { dAtA[i] = 0x18 i++ if m.Succeed { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.PreviousNotExist { dAtA[i] = 0x20 i++ if m.PreviousNotExist { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.PreviousValue) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.PreviousValue))) i += copy(dAtA[i:], m.PreviousValue) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetLockWaitInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetLockWaitInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n123, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n123 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetLockWaitInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetLockWaitInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n124, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n124 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawCoprocessorRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawCoprocessorRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n125, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n125 } if len(m.CoprName) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.CoprName))) i += copy(dAtA[i:], m.CoprName) } if len(m.CoprVersionReq) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.CoprVersionReq))) i += copy(dAtA[i:], m.CoprVersionReq) } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x22 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Data) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawCoprocessorResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawCoprocessorResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n126, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n126 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if len(m.Data) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawChecksumRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawChecksumRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Context != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Context.Size())) n127, err := m.Context.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n127 } if m.Algorithm != 0 { dAtA[i] = 0x10 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Algorithm)) } if len(m.Ranges) > 0 { for _, msg := range m.Ranges { dAtA[i] = 0x1a i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RawChecksumResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RawChecksumResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionError != nil { dAtA[i] = 0xa i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.RegionError.Size())) n128, err := m.RegionError.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n128 } if len(m.Error) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } if m.Checksum != 0 { dAtA[i] = 0x18 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Checksum)) } if m.TotalKvs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TotalKvs)) } if m.TotalBytes != 0 { dAtA[i] = 0x28 i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.TotalBytes)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintKvrpcpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *GetRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Version != 0 { n += 1 + sovKvrpcpb(uint64(m.Version)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.NotFound { n += 2 } if m.ExecDetailsV2 != nil { l = m.ExecDetailsV2.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovKvrpcpb(uint64(m.Limit)) } if m.Version != 0 { n += 1 + sovKvrpcpb(uint64(m.Version)) } if m.KeyOnly { n += 2 } if m.Reverse { n += 2 } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.SampleStep != 0 { n += 1 + sovKvrpcpb(uint64(m.SampleStep)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrewriteRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Mutations) > 0 { for _, e := range m.Mutations { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.PrimaryLock) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } if m.SkipConstraintCheck { n += 2 } if len(m.IsPessimisticLock) > 0 { n += 1 + sovKvrpcpb(uint64(len(m.IsPessimisticLock))) + len(m.IsPessimisticLock)*1 } if m.TxnSize != 0 { n += 1 + sovKvrpcpb(uint64(m.TxnSize)) } if m.ForUpdateTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ForUpdateTs)) } if m.MinCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MinCommitTs)) } if m.UseAsyncCommit { n += 2 } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.TryOnePc { n += 2 } if m.MaxCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxCommitTs)) } if m.AssertionLevel != 0 { n += 1 + sovKvrpcpb(uint64(m.AssertionLevel)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrewriteResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Errors) > 0 { for _, e := range m.Errors { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.MinCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MinCommitTs)) } if m.OnePcCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.OnePcCommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PessimisticLockRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Mutations) > 0 { for _, e := range m.Mutations { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.PrimaryLock) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } if m.ForUpdateTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ForUpdateTs)) } if m.IsFirstLock { n += 2 } if m.WaitTimeout != 0 { n += 1 + sovKvrpcpb(uint64(m.WaitTimeout)) } if m.Force { n += 2 } if m.ReturnValues { n += 2 } if m.MinCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MinCommitTs)) } if m.CheckExistence { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PessimisticLockResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Errors) > 0 { for _, e := range m.Errors { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.CommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitTs)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Values) > 0 { for _, b := range m.Values { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if len(m.NotFounds) > 0 { n += 1 + sovKvrpcpb(uint64(len(m.NotFounds))) + len(m.NotFounds)*1 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PessimisticRollbackRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.ForUpdateTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ForUpdateTs)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PessimisticRollbackResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Errors) > 0 { for _, e := range m.Errors { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnHeartBeatRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.PrimaryLock) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.AdviseLockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.AdviseLockTtl)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnHeartBeatResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckTxnStatusRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.PrimaryKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.LockTs != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTs)) } if m.CallerStartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CallerStartTs)) } if m.CurrentTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CurrentTs)) } if m.RollbackIfNotExist { n += 2 } if m.ForceSyncCommit { n += 2 } if m.ResolvingPessimisticLock { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckTxnStatusResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if m.Action != 0 { n += 1 + sovKvrpcpb(uint64(m.Action)) } if m.LockInfo != nil { l = m.LockInfo.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckSecondaryLocksRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckSecondaryLocksResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Locks) > 0 { for _, e := range m.Locks { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.CommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImportRequest) Size() (n int) { var l int _ = l if len(m.Mutations) > 0 { for _, e := range m.Mutations { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ImportResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CleanupRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.CurrentTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CurrentTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CleanupResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchGetRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.Version != 0 { n += 1 + sovKvrpcpb(uint64(m.Version)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchGetResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.ExecDetailsV2 != nil { l = m.ExecDetailsV2.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchRollbackRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchRollbackResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanLockRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MaxVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxVersion)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovKvrpcpb(uint64(m.Limit)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanLockResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Locks) > 0 { for _, e := range m.Locks { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResolveLockRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } if len(m.TxnInfos) > 0 { for _, e := range m.TxnInfos { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResolveLockResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GCRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.SafePoint != 0 { n += 1 + sovKvrpcpb(uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GCResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRangeRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.NotifyOnly { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRangeResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawGetRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawGetResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.NotFound { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchGetRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchGetResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawPutRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Ttl != 0 { n += 1 + sovKvrpcpb(uint64(m.Ttl)) } if m.ForCas { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawPutResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchPutRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Pairs) > 0 { for _, e := range m.Pairs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Ttl != 0 { n += 1 + sovKvrpcpb(uint64(m.Ttl)) } if m.ForCas { n += 2 } if len(m.Ttls) > 0 { l = 0 for _, e := range m.Ttls { l += sovKvrpcpb(uint64(e)) } n += 1 + sovKvrpcpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchPutResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawDeleteRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ForCas { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawDeleteResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchDeleteRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ForCas { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchDeleteResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawScanRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovKvrpcpb(uint64(m.Limit)) } if m.KeyOnly { n += 2 } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Reverse { n += 2 } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawScanResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Kvs) > 0 { for _, e := range m.Kvs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawDeleteRangeRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawDeleteRangeResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchScanRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.EachLimit != 0 { n += 1 + sovKvrpcpb(uint64(m.EachLimit)) } if m.KeyOnly { n += 2 } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Reverse { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawBatchScanResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Kvs) > 0 { for _, e := range m.Kvs { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UnsafeDestroyRangeRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UnsafeDestroyRangeResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegisterLockObserverRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MaxTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegisterLockObserverResponse) Size() (n int) { var l int _ = l l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckLockObserverRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MaxTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckLockObserverResponse) Size() (n int) { var l int _ = l l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.IsClean { n += 2 } if len(m.Locks) > 0 { for _, e := range m.Locks { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RemoveLockObserverRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MaxTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RemoveLockObserverResponse) Size() (n int) { var l int _ = l l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PhysicalScanLockRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MaxTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxTs)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovKvrpcpb(uint64(m.Limit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PhysicalScanLockResponse) Size() (n int) { var l int _ = l l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Locks) > 0 { for _, e := range m.Locks { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRegionRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.SplitKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.IsRawKv { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRegionResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Left != nil { l = m.Left.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Right != nil { l = m.Right.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadIndexRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadIndexResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ReadIndex != 0 { n += 1 + sovKvrpcpb(uint64(m.ReadIndex)) } if m.Locked != nil { l = m.Locked.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccGetByKeyRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccGetByKeyResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Info != nil { l = m.Info.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccGetByStartTsRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccGetByStartTsResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Info != nil { l = m.Info.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Context) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovKvrpcpb(uint64(m.RegionId)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Term != 0 { n += 1 + sovKvrpcpb(uint64(m.Term)) } if m.Priority != 0 { n += 1 + sovKvrpcpb(uint64(m.Priority)) } if m.IsolationLevel != 0 { n += 1 + sovKvrpcpb(uint64(m.IsolationLevel)) } if m.NotFillCache { n += 2 } if m.SyncLog { n += 2 } if m.RecordTimeStat { n += 2 } if m.RecordScanStat { n += 2 } if m.ReplicaRead { n += 2 } if len(m.ResolvedLocks) > 0 { l = 0 for _, e := range m.ResolvedLocks { l += sovKvrpcpb(uint64(e)) } n += 1 + sovKvrpcpb(uint64(l)) + l } if m.MaxExecutionDurationMs != 0 { n += 1 + sovKvrpcpb(uint64(m.MaxExecutionDurationMs)) } if m.AppliedIndex != 0 { n += 1 + sovKvrpcpb(uint64(m.AppliedIndex)) } if m.TaskId != 0 { n += 2 + sovKvrpcpb(uint64(m.TaskId)) } if m.StaleRead { n += 3 } l = len(m.ResourceGroupTag) if l > 0 { n += 2 + l + sovKvrpcpb(uint64(l)) } if m.DiskFullOpt != 0 { n += 2 + sovKvrpcpb(uint64(m.DiskFullOpt)) } if m.IsRetryRequest { n += 3 } if m.ApiVersion != 0 { n += 2 + sovKvrpcpb(uint64(m.ApiVersion)) } if len(m.CommittedLocks) > 0 { l = 0 for _, e := range m.CommittedLocks { l += sovKvrpcpb(uint64(e)) } n += 2 + sovKvrpcpb(uint64(l)) + l } if m.TraceContext != nil { l = m.TraceContext.Size() n += 2 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LockInfo) Size() (n int) { var l int _ = l l = len(m.PrimaryLock) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.LockVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.LockVersion)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } if m.TxnSize != 0 { n += 1 + sovKvrpcpb(uint64(m.TxnSize)) } if m.LockType != 0 { n += 1 + sovKvrpcpb(uint64(m.LockType)) } if m.LockForUpdateTs != 0 { n += 1 + sovKvrpcpb(uint64(m.LockForUpdateTs)) } if m.UseAsyncCommit { n += 2 } if m.MinCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MinCommitTs)) } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KeyError) Size() (n int) { var l int _ = l if m.Locked != nil { l = m.Locked.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Retryable) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Abort) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Conflict != nil { l = m.Conflict.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.AlreadyExist != nil { l = m.AlreadyExist.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Deadlock != nil { l = m.Deadlock.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.CommitTsExpired != nil { l = m.CommitTsExpired.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.TxnNotFound != nil { l = m.TxnNotFound.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.CommitTsTooLarge != nil { l = m.CommitTsTooLarge.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.AssertionFailed != nil { l = m.AssertionFailed.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WriteConflict) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } if m.ConflictTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ConflictTs)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Primary) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ConflictCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ConflictCommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AlreadyExist) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Deadlock) Size() (n int) { var l int _ = l if m.LockTs != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTs)) } l = len(m.LockKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.DeadlockKeyHash != 0 { n += 1 + sovKvrpcpb(uint64(m.DeadlockKeyHash)) } if len(m.WaitChain) > 0 { for _, e := range m.WaitChain { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitTsExpired) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } if m.AttemptedCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.AttemptedCommitTs)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.MinCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.MinCommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnNotFound) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } l = len(m.PrimaryKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitTsTooLarge) Size() (n int) { var l int _ = l if m.CommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AssertionFailed) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Assertion != 0 { n += 1 + sovKvrpcpb(uint64(m.Assertion)) } if m.ExistingStartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ExistingStartTs)) } if m.ExistingCommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ExistingCommitTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TimeDetail) Size() (n int) { var l int _ = l if m.WaitWallTimeMs != 0 { n += 1 + sovKvrpcpb(uint64(m.WaitWallTimeMs)) } if m.ProcessWallTimeMs != 0 { n += 1 + sovKvrpcpb(uint64(m.ProcessWallTimeMs)) } if m.KvReadWallTimeMs != 0 { n += 1 + sovKvrpcpb(uint64(m.KvReadWallTimeMs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanInfo) Size() (n int) { var l int _ = l if m.Total != 0 { n += 1 + sovKvrpcpb(uint64(m.Total)) } if m.Processed != 0 { n += 1 + sovKvrpcpb(uint64(m.Processed)) } if m.ReadBytes != 0 { n += 1 + sovKvrpcpb(uint64(m.ReadBytes)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanDetail) Size() (n int) { var l int _ = l if m.Write != nil { l = m.Write.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Lock != nil { l = m.Lock.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Data != nil { l = m.Data.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanDetailV2) Size() (n int) { var l int _ = l if m.ProcessedVersions != 0 { n += 1 + sovKvrpcpb(uint64(m.ProcessedVersions)) } if m.TotalVersions != 0 { n += 1 + sovKvrpcpb(uint64(m.TotalVersions)) } if m.RocksdbDeleteSkippedCount != 0 { n += 1 + sovKvrpcpb(uint64(m.RocksdbDeleteSkippedCount)) } if m.RocksdbKeySkippedCount != 0 { n += 1 + sovKvrpcpb(uint64(m.RocksdbKeySkippedCount)) } if m.RocksdbBlockCacheHitCount != 0 { n += 1 + sovKvrpcpb(uint64(m.RocksdbBlockCacheHitCount)) } if m.RocksdbBlockReadCount != 0 { n += 1 + sovKvrpcpb(uint64(m.RocksdbBlockReadCount)) } if m.RocksdbBlockReadByte != 0 { n += 1 + sovKvrpcpb(uint64(m.RocksdbBlockReadByte)) } if m.ProcessedVersionsSize != 0 { n += 1 + sovKvrpcpb(uint64(m.ProcessedVersionsSize)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExecDetails) Size() (n int) { var l int _ = l if m.TimeDetail != nil { l = m.TimeDetail.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ScanDetail != nil { l = m.ScanDetail.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExecDetailsV2) Size() (n int) { var l int _ = l if m.TimeDetail != nil { l = m.TimeDetail.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ScanDetailV2 != nil { l = m.ScanDetailV2.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KvPair) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Mutation) Size() (n int) { var l int _ = l if m.Op != 0 { n += 1 + sovKvrpcpb(uint64(m.Op)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Assertion != 0 { n += 1 + sovKvrpcpb(uint64(m.Assertion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccWrite) Size() (n int) { var l int _ = l if m.Type != 0 { n += 1 + sovKvrpcpb(uint64(m.Type)) } if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } if m.CommitTs != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitTs)) } l = len(m.ShortValue) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.HasOverlappedRollback { n += 2 } if m.HasGcFence { n += 2 } if m.GcFence != 0 { n += 1 + sovKvrpcpb(uint64(m.GcFence)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccValue) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccLock) Size() (n int) { var l int _ = l if m.Type != 0 { n += 1 + sovKvrpcpb(uint64(m.Type)) } if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } l = len(m.Primary) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.ShortValue) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Ttl != 0 { n += 1 + sovKvrpcpb(uint64(m.Ttl)) } if m.ForUpdateTs != 0 { n += 1 + sovKvrpcpb(uint64(m.ForUpdateTs)) } if m.TxnSize != 0 { n += 1 + sovKvrpcpb(uint64(m.TxnSize)) } if m.UseAsyncCommit { n += 2 } if len(m.Secondaries) > 0 { for _, b := range m.Secondaries { l = len(b) n += 1 + l + sovKvrpcpb(uint64(l)) } } if len(m.RollbackTs) > 0 { l = 0 for _, e := range m.RollbackTs { l += sovKvrpcpb(uint64(e)) } n += 1 + sovKvrpcpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MvccInfo) Size() (n int) { var l int _ = l if m.Lock != nil { l = m.Lock.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Writes) > 0 { for _, e := range m.Writes { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if len(m.Values) > 0 { for _, e := range m.Values { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TxnInfo) Size() (n int) { var l int _ = l if m.Txn != 0 { n += 1 + sovKvrpcpb(uint64(m.Txn)) } if m.Status != 0 { n += 1 + sovKvrpcpb(uint64(m.Status)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KeyRange) Size() (n int) { var l int _ = l l = len(m.StartKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LeaderInfo) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovKvrpcpb(uint64(m.RegionId)) } if m.PeerId != 0 { n += 1 + sovKvrpcpb(uint64(m.PeerId)) } if m.Term != 0 { n += 1 + sovKvrpcpb(uint64(m.Term)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.ReadState != nil { l = m.ReadState.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadState) Size() (n int) { var l int _ = l if m.AppliedIndex != 0 { n += 1 + sovKvrpcpb(uint64(m.AppliedIndex)) } if m.SafeTs != 0 { n += 1 + sovKvrpcpb(uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckLeaderRequest) Size() (n int) { var l int _ = l if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.Ts != 0 { n += 1 + sovKvrpcpb(uint64(m.Ts)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CheckLeaderResponse) Size() (n int) { var l int _ = l if len(m.Regions) > 0 { l = 0 for _, e := range m.Regions { l += sovKvrpcpb(uint64(e)) } n += 1 + sovKvrpcpb(uint64(l)) + l } if m.Ts != 0 { n += 1 + sovKvrpcpb(uint64(m.Ts)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreSafeTSRequest) Size() (n int) { var l int _ = l if m.KeyRange != nil { l = m.KeyRange.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreSafeTSResponse) Size() (n int) { var l int _ = l if m.SafeTs != 0 { n += 1 + sovKvrpcpb(uint64(m.SafeTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawGetKeyTTLRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawGetKeyTTLResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Ttl != 0 { n += 1 + sovKvrpcpb(uint64(m.Ttl)) } if m.NotFound { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawCASRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.PreviousNotExist { n += 2 } l = len(m.PreviousValue) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Cf) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Ttl != 0 { n += 1 + sovKvrpcpb(uint64(m.Ttl)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawCASResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Succeed { n += 2 } if m.PreviousNotExist { n += 2 } l = len(m.PreviousValue) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetLockWaitInfoRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetLockWaitInfoResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawCoprocessorRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.CoprName) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.CoprVersionReq) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } l = len(m.Data) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawCoprocessorResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Data) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawChecksumRequest) Size() (n int) { var l int _ = l if m.Context != nil { l = m.Context.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Algorithm != 0 { n += 1 + sovKvrpcpb(uint64(m.Algorithm)) } if len(m.Ranges) > 0 { for _, e := range m.Ranges { l = e.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RawChecksumResponse) Size() (n int) { var l int _ = l if m.RegionError != nil { l = m.RegionError.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } l = len(m.Error) if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } if m.Checksum != 0 { n += 1 + sovKvrpcpb(uint64(m.Checksum)) } if m.TotalKvs != 0 { n += 1 + sovKvrpcpb(uint64(m.TotalKvs)) } if m.TotalBytes != 0 { n += 1 + sovKvrpcpb(uint64(m.TotalBytes)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovKvrpcpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozKvrpcpb(x uint64) (n int) { return sovKvrpcpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } 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 ErrIntOverflowKvrpcpb } 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 Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 ErrIntOverflowKvrpcpb } 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 RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotFound", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFound = bool(v != 0) case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExecDetailsV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExecDetailsV2 == nil { m.ExecDetailsV2 = &ExecDetailsV2{} } if err := m.ExecDetailsV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanRequest) 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 ErrIntOverflowKvrpcpb } 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: ScanRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.KeyOnly = bool(v != 0) case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Reverse = bool(v != 0) case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SampleStep", wireType) } m.SampleStep = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SampleStep |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanResponse) 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 ErrIntOverflowKvrpcpb } 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: ScanResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KvPair{}) if err := m.Pairs[len(m.Pairs)-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 Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PrewriteRequest) 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 ErrIntOverflowKvrpcpb } 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: PrewriteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrewriteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Mutations = append(m.Mutations, &Mutation{}) if err := m.Mutations[len(m.Mutations)-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 PrimaryLock", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryLock == nil { m.PrimaryLock = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType) } m.LockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SkipConstraintCheck", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SkipConstraintCheck = bool(v != 0) case 7: if wireType == 0 { var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsPessimisticLock = append(m.IsPessimisticLock, bool(v != 0)) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsPessimisticLock = append(m.IsPessimisticLock, bool(v != 0)) } } else { return fmt.Errorf("proto: wrong wireType = %d for field IsPessimisticLock", wireType) } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TxnSize", wireType) } m.TxnSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TxnSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForUpdateTs", wireType) } m.ForUpdateTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ForUpdateTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UseAsyncCommit", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.UseAsyncCommit = bool(v != 0) case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Secondaries", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Secondaries = append(m.Secondaries, make([]byte, postIndex-iNdEx)) copy(m.Secondaries[len(m.Secondaries)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TryOnePc", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.TryOnePc = bool(v != 0) case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxCommitTs", wireType) } m.MaxCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 15: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AssertionLevel", wireType) } m.AssertionLevel = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AssertionLevel |= (AssertionLevel(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PrewriteResponse) 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 ErrIntOverflowKvrpcpb } 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: PrewriteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrewriteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Errors = append(m.Errors, &KeyError{}) if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field OnePcCommitTs", wireType) } m.OnePcCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.OnePcCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PessimisticLockRequest) 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 ErrIntOverflowKvrpcpb } 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: PessimisticLockRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PessimisticLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Mutations = append(m.Mutations, &Mutation{}) if err := m.Mutations[len(m.Mutations)-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 PrimaryLock", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryLock == nil { m.PrimaryLock = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType) } m.LockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForUpdateTs", wireType) } m.ForUpdateTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ForUpdateTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsFirstLock", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsFirstLock = bool(v != 0) case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WaitTimeout", wireType) } m.WaitTimeout = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WaitTimeout |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Force", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Force = bool(v != 0) case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReturnValues", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ReturnValues = bool(v != 0) case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CheckExistence", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.CheckExistence = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PessimisticLockResponse) 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 ErrIntOverflowKvrpcpb } 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: PessimisticLockResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PessimisticLockResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Errors = append(m.Errors, &KeyError{}) if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Values = append(m.Values, make([]byte, postIndex-iNdEx)) copy(m.Values[len(m.Values)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType == 0 { var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFounds = append(m.NotFounds, bool(v != 0)) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFounds = append(m.NotFounds, bool(v != 0)) } } else { return fmt.Errorf("proto: wrong wireType = %d for field NotFounds", wireType) } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PessimisticRollbackRequest) 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 ErrIntOverflowKvrpcpb } 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: PessimisticRollbackRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PessimisticRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForUpdateTs", wireType) } m.ForUpdateTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ForUpdateTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PessimisticRollbackResponse) 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 ErrIntOverflowKvrpcpb } 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: PessimisticRollbackResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PessimisticRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Errors = append(m.Errors, &KeyError{}) if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *TxnHeartBeatRequest) 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 ErrIntOverflowKvrpcpb } 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: TxnHeartBeatRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnHeartBeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryLock == nil { m.PrimaryLock = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AdviseLockTtl", wireType) } m.AdviseLockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AdviseLockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *TxnHeartBeatResponse) 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 ErrIntOverflowKvrpcpb } 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: TxnHeartBeatResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnHeartBeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType) } m.LockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckTxnStatusRequest) 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 ErrIntOverflowKvrpcpb } 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: CheckTxnStatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckTxnStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryKey = append(m.PrimaryKey[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryKey == nil { m.PrimaryKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTs", wireType) } m.LockTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CallerStartTs", wireType) } m.CallerStartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CallerStartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CurrentTs", wireType) } m.CurrentTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CurrentTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RollbackIfNotExist", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RollbackIfNotExist = bool(v != 0) case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForceSyncCommit", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForceSyncCommit = bool(v != 0) case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ResolvingPessimisticLock", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ResolvingPessimisticLock = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckTxnStatusResponse) 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 ErrIntOverflowKvrpcpb } 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: CheckTxnStatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckTxnStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType) } m.LockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Action |= (Action(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LockInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.LockInfo == nil { m.LockInfo = &LockInfo{} } if err := m.LockInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckSecondaryLocksRequest) 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 ErrIntOverflowKvrpcpb } 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: CheckSecondaryLocksRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckSecondaryLocksRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckSecondaryLocksResponse) 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 ErrIntOverflowKvrpcpb } 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: CheckSecondaryLocksResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckSecondaryLocksResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Locks = append(m.Locks, &LockInfo{}) if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CommitRequest) 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 ErrIntOverflowKvrpcpb } 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: CommitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CommitResponse) 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 ErrIntOverflowKvrpcpb } 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: CommitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ImportRequest) 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 ErrIntOverflowKvrpcpb } 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: ImportRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImportRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Mutations = append(m.Mutations, &Mutation{}) if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ImportResponse) 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 ErrIntOverflowKvrpcpb } 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: ImportResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImportResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 ErrIntOverflowKvrpcpb } 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 Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CurrentTs", wireType) } m.CurrentTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CurrentTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CleanupResponse) 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 ErrIntOverflowKvrpcpb } 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: CleanupResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CleanupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *BatchGetRequest) 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 ErrIntOverflowKvrpcpb } 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: BatchGetRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *BatchGetResponse) 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 ErrIntOverflowKvrpcpb } 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: BatchGetResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KvPair{}) if err := m.Pairs[len(m.Pairs)-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 ExecDetailsV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExecDetailsV2 == nil { m.ExecDetailsV2 = &ExecDetailsV2{} } if err := m.ExecDetailsV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *BatchRollbackRequest) 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 ErrIntOverflowKvrpcpb } 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: BatchRollbackRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *BatchRollbackResponse) 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 ErrIntOverflowKvrpcpb } 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: BatchRollbackResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanLockRequest) 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 ErrIntOverflowKvrpcpb } 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: ScanLockRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxVersion", wireType) } m.MaxVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanLockResponse) 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 ErrIntOverflowKvrpcpb } 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: ScanLockResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanLockResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Locks = append(m.Locks, &LockInfo{}) if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ResolveLockRequest) 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 ErrIntOverflowKvrpcpb } 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: ResolveLockRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitVersion", wireType) } m.CommitVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnInfos", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.TxnInfos = append(m.TxnInfos, &TxnInfo{}) if err := m.TxnInfos[len(m.TxnInfos)-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 Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ResolveLockResponse) 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 ErrIntOverflowKvrpcpb } 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: ResolveLockResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResolveLockResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *GCRequest) 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 ErrIntOverflowKvrpcpb } 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: GCRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GCRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *GCResponse) 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 ErrIntOverflowKvrpcpb } 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: GCResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GCResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *DeleteRangeRequest) 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 ErrIntOverflowKvrpcpb } 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: DeleteRangeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotifyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotifyOnly = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *DeleteRangeResponse) 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 ErrIntOverflowKvrpcpb } 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: DeleteRangeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawGetRequest) 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 ErrIntOverflowKvrpcpb } 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: RawGetRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawGetResponse) 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 ErrIntOverflowKvrpcpb } 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: RawGetResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotFound", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFound = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchGetRequest) 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 ErrIntOverflowKvrpcpb } 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: RawBatchGetRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchGetRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchGetResponse) 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 ErrIntOverflowKvrpcpb } 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: RawBatchGetResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchGetResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KvPair{}) if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawPutRequest) 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 ErrIntOverflowKvrpcpb } 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: RawPutRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawPutRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForCas", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForCas = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawPutResponse) 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 ErrIntOverflowKvrpcpb } 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: RawPutResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawPutResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchPutRequest) 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 ErrIntOverflowKvrpcpb } 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: RawBatchPutRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchPutRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Pairs = append(m.Pairs, &KvPair{}) if err := m.Pairs[len(m.Pairs)-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 Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForCas", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForCas = bool(v != 0) case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Ttls = append(m.Ttls, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Ttls = append(m.Ttls, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Ttls", wireType) } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchPutResponse) 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 ErrIntOverflowKvrpcpb } 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: RawBatchPutResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchPutResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawDeleteRequest) 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 ErrIntOverflowKvrpcpb } 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: RawDeleteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForCas", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForCas = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawDeleteResponse) 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 ErrIntOverflowKvrpcpb } 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: RawDeleteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchDeleteRequest) 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 ErrIntOverflowKvrpcpb } 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: RawBatchDeleteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForCas", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForCas = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchDeleteResponse) 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 ErrIntOverflowKvrpcpb } 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: RawBatchDeleteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawScanRequest) 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 ErrIntOverflowKvrpcpb } 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: RawScanRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawScanRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.KeyOnly = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Reverse = bool(v != 0) case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawScanResponse) 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 ErrIntOverflowKvrpcpb } 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: RawScanResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawScanResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Kvs = append(m.Kvs, &KvPair{}) if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawDeleteRangeRequest) 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 ErrIntOverflowKvrpcpb } 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: RawDeleteRangeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawDeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawDeleteRangeResponse) 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 ErrIntOverflowKvrpcpb } 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: RawDeleteRangeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawDeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchScanRequest) 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 ErrIntOverflowKvrpcpb } 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: RawBatchScanRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchScanRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EachLimit", wireType) } m.EachLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EachLimit |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.KeyOnly = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Reverse = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawBatchScanResponse) 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 ErrIntOverflowKvrpcpb } 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: RawBatchScanResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawBatchScanResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Kvs = append(m.Kvs, &KvPair{}) if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *UnsafeDestroyRangeRequest) 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 ErrIntOverflowKvrpcpb } 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: UnsafeDestroyRangeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeDestroyRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *UnsafeDestroyRangeResponse) 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 ErrIntOverflowKvrpcpb } 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: UnsafeDestroyRangeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeDestroyRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RegisterLockObserverRequest) 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 ErrIntOverflowKvrpcpb } 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: RegisterLockObserverRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegisterLockObserverRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } m.MaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RegisterLockObserverResponse) 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 ErrIntOverflowKvrpcpb } 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: RegisterLockObserverResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegisterLockObserverResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckLockObserverRequest) 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 ErrIntOverflowKvrpcpb } 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: CheckLockObserverRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckLockObserverRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } m.MaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckLockObserverResponse) 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 ErrIntOverflowKvrpcpb } 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: CheckLockObserverResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckLockObserverResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsClean", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsClean = bool(v != 0) case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Locks = append(m.Locks, &LockInfo{}) if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RemoveLockObserverRequest) 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 ErrIntOverflowKvrpcpb } 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: RemoveLockObserverRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoveLockObserverRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } m.MaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RemoveLockObserverResponse) 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 ErrIntOverflowKvrpcpb } 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: RemoveLockObserverResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoveLockObserverResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PhysicalScanLockRequest) 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 ErrIntOverflowKvrpcpb } 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: PhysicalScanLockRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PhysicalScanLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } m.MaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *PhysicalScanLockResponse) 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 ErrIntOverflowKvrpcpb } 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: PhysicalScanLockResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PhysicalScanLockResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Locks = append(m.Locks, &LockInfo{}) if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *SplitRegionRequest) 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 ErrIntOverflowKvrpcpb } 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: SplitRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.SplitKey = append(m.SplitKey[:0], dAtA[iNdEx:postIndex]...) if m.SplitKey == nil { m.SplitKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitKeys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.SplitKeys = append(m.SplitKeys, make([]byte, postIndex-iNdEx)) copy(m.SplitKeys[len(m.SplitKeys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRawKv = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *SplitRegionResponse) 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 ErrIntOverflowKvrpcpb } 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: SplitRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Left == nil { m.Left = &metapb.Region{} } if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Right == nil { m.Right = &metapb.Region{} } if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &metapb.Region{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ReadIndexRequest) 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 ErrIntOverflowKvrpcpb } 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: ReadIndexRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ReadIndexResponse) 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 ErrIntOverflowKvrpcpb } 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: ReadIndexResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIndex", wireType) } m.ReadIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Locked == nil { m.Locked = &LockInfo{} } if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccGetByKeyRequest) 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 ErrIntOverflowKvrpcpb } 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: MvccGetByKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccGetByKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccGetByKeyResponse) 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 ErrIntOverflowKvrpcpb } 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: MvccGetByKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccGetByKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Info == nil { m.Info = &MvccInfo{} } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccGetByStartTsRequest) 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 ErrIntOverflowKvrpcpb } 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: MvccGetByStartTsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccGetByStartTsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccGetByStartTsResponse) 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 ErrIntOverflowKvrpcpb } 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: MvccGetByStartTsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccGetByStartTsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 4: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Info == nil { m.Info = &MvccInfo{} } if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *Context) 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 ErrIntOverflowKvrpcpb } 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: Context: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Context: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType) } m.Priority = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Priority |= (CommandPri(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsolationLevel", wireType) } m.IsolationLevel = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.IsolationLevel |= (IsolationLevel(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotFillCache", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFillCache = bool(v != 0) case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SyncLog = bool(v != 0) case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RecordTimeStat", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RecordTimeStat = bool(v != 0) case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RecordScanStat", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RecordScanStat = bool(v != 0) case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicaRead", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ReplicaRead = bool(v != 0) case 13: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ResolvedLocks = append(m.ResolvedLocks, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ResolvedLocks = append(m.ResolvedLocks, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field ResolvedLocks", wireType) } case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxExecutionDurationMs", wireType) } m.MaxExecutionDurationMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxExecutionDurationMs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 15: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType) } m.AppliedIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AppliedIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 16: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType) } m.TaskId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TaskId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 17: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StaleRead", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.StaleRead = bool(v != 0) case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceGroupTag", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ResourceGroupTag = append(m.ResourceGroupTag[:0], dAtA[iNdEx:postIndex]...) if m.ResourceGroupTag == nil { m.ResourceGroupTag = []byte{} } iNdEx = postIndex case 19: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DiskFullOpt", wireType) } m.DiskFullOpt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DiskFullOpt |= (DiskFullOpt(b) & 0x7F) << shift if b < 0x80 { break } } case 20: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsRetryRequest", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsRetryRequest = bool(v != 0) case 21: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } case 22: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.CommittedLocks = append(m.CommittedLocks, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.CommittedLocks = append(m.CommittedLocks, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field CommittedLocks", wireType) } case 23: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TraceContext", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TraceContext == nil { m.TraceContext = &tracepb.TraceContext{} } if err := m.TraceContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *LockInfo) 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 ErrIntOverflowKvrpcpb } 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: LockInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LockInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrimaryLock", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryLock = append(m.PrimaryLock[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryLock == nil { m.PrimaryLock = []byte{} } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockVersion", wireType) } m.LockVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockVersion |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTtl", wireType) } m.LockTtl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTtl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TxnSize", wireType) } m.TxnSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TxnSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockType", wireType) } m.LockType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockType |= (Op(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockForUpdateTs", wireType) } m.LockForUpdateTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockForUpdateTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UseAsyncCommit", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.UseAsyncCommit = bool(v != 0) case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Secondaries", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Secondaries = append(m.Secondaries, make([]byte, postIndex-iNdEx)) copy(m.Secondaries[len(m.Secondaries)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *KeyError) 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 ErrIntOverflowKvrpcpb } 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: KeyError: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyError: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Locked == nil { m.Locked = &LockInfo{} } if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Retryable", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Retryable = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Abort", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Abort = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Conflict", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Conflict == nil { m.Conflict = &WriteConflict{} } if err := m.Conflict.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AlreadyExist", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AlreadyExist == nil { m.AlreadyExist = &AlreadyExist{} } if err := m.AlreadyExist.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Deadlock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Deadlock == nil { m.Deadlock = &Deadlock{} } if err := m.Deadlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTsExpired", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CommitTsExpired == nil { m.CommitTsExpired = &CommitTsExpired{} } if err := m.CommitTsExpired.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnNotFound", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TxnNotFound == nil { m.TxnNotFound = &TxnNotFound{} } if err := m.TxnNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTsTooLarge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CommitTsTooLarge == nil { m.CommitTsTooLarge = &CommitTsTooLarge{} } if err := m.CommitTsTooLarge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AssertionFailed", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AssertionFailed == nil { m.AssertionFailed = &AssertionFailed{} } if err := m.AssertionFailed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *WriteConflict) 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 ErrIntOverflowKvrpcpb } 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: WriteConflict: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WriteConflict: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ConflictTs", wireType) } m.ConflictTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ConflictTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Primary = append(m.Primary[:0], dAtA[iNdEx:postIndex]...) if m.Primary == nil { m.Primary = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ConflictCommitTs", wireType) } m.ConflictCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ConflictCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *AlreadyExist) 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 ErrIntOverflowKvrpcpb } 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: AlreadyExist: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AlreadyExist: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *Deadlock) 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 ErrIntOverflowKvrpcpb } 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: Deadlock: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Deadlock: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LockTs", wireType) } m.LockTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LockTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LockKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.LockKey = append(m.LockKey[:0], dAtA[iNdEx:postIndex]...) if m.LockKey == nil { m.LockKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DeadlockKeyHash", wireType) } m.DeadlockKeyHash = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DeadlockKeyHash |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WaitChain", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.WaitChain = append(m.WaitChain, &deadlock.WaitForEntry{}) if err := m.WaitChain[len(m.WaitChain)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CommitTsExpired) 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 ErrIntOverflowKvrpcpb } 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: CommitTsExpired: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitTsExpired: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AttemptedCommitTs", wireType) } m.AttemptedCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AttemptedCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType) } m.MinCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *TxnNotFound) 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 ErrIntOverflowKvrpcpb } 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: TxnNotFound: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnNotFound: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PrimaryKey = append(m.PrimaryKey[:0], dAtA[iNdEx:postIndex]...) if m.PrimaryKey == nil { m.PrimaryKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CommitTsTooLarge) 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 ErrIntOverflowKvrpcpb } 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: CommitTsTooLarge: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitTsTooLarge: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *AssertionFailed) 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 ErrIntOverflowKvrpcpb } 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: AssertionFailed: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AssertionFailed: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Assertion", wireType) } m.Assertion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Assertion |= (Assertion(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExistingStartTs", wireType) } m.ExistingStartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExistingStartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExistingCommitTs", wireType) } m.ExistingCommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExistingCommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *TimeDetail) 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 ErrIntOverflowKvrpcpb } 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: TimeDetail: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TimeDetail: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WaitWallTimeMs", wireType) } m.WaitWallTimeMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WaitWallTimeMs |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ProcessWallTimeMs", wireType) } m.ProcessWallTimeMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ProcessWallTimeMs |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KvReadWallTimeMs", wireType) } m.KvReadWallTimeMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KvReadWallTimeMs |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanInfo) 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 ErrIntOverflowKvrpcpb } 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: ScanInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Total |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Processed", wireType) } m.Processed = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Processed |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType) } m.ReadBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadBytes |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanDetail) 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 ErrIntOverflowKvrpcpb } 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: ScanDetail: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanDetail: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Write == nil { m.Write = &ScanInfo{} } if err := m.Write.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Lock == nil { m.Lock = &ScanInfo{} } if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Data == nil { m.Data = &ScanInfo{} } if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ScanDetailV2) 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 ErrIntOverflowKvrpcpb } 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: ScanDetailV2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanDetailV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ProcessedVersions", wireType) } m.ProcessedVersions = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ProcessedVersions |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalVersions", wireType) } m.TotalVersions = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalVersions |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbDeleteSkippedCount", wireType) } m.RocksdbDeleteSkippedCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RocksdbDeleteSkippedCount |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbKeySkippedCount", wireType) } m.RocksdbKeySkippedCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RocksdbKeySkippedCount |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbBlockCacheHitCount", wireType) } m.RocksdbBlockCacheHitCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RocksdbBlockCacheHitCount |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbBlockReadCount", wireType) } m.RocksdbBlockReadCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RocksdbBlockReadCount |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RocksdbBlockReadByte", wireType) } m.RocksdbBlockReadByte = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RocksdbBlockReadByte |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ProcessedVersionsSize", wireType) } m.ProcessedVersionsSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ProcessedVersionsSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ExecDetails) 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 ErrIntOverflowKvrpcpb } 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: ExecDetails: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecDetails: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TimeDetail", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TimeDetail == nil { m.TimeDetail = &TimeDetail{} } if err := m.TimeDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ScanDetail", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ScanDetail == nil { m.ScanDetail = &ScanDetail{} } if err := m.ScanDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ExecDetailsV2) 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 ErrIntOverflowKvrpcpb } 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: ExecDetailsV2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecDetailsV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TimeDetail", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TimeDetail == nil { m.TimeDetail = &TimeDetail{} } if err := m.TimeDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ScanDetailV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ScanDetailV2 == nil { m.ScanDetailV2 = &ScanDetailV2{} } if err := m.ScanDetailV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *KvPair) 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 ErrIntOverflowKvrpcpb } 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: KvPair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KvPair: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &KeyError{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *Mutation) 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 ErrIntOverflowKvrpcpb } 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: Mutation: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Mutation: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType) } m.Op = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Op |= (Op(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Assertion", wireType) } m.Assertion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Assertion |= (Assertion(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccWrite) 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 ErrIntOverflowKvrpcpb } 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: MvccWrite: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccWrite: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= (Op(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType) } m.CommitTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ShortValue", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ShortValue = append(m.ShortValue[:0], dAtA[iNdEx:postIndex]...) if m.ShortValue == nil { m.ShortValue = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HasOverlappedRollback", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.HasOverlappedRollback = bool(v != 0) case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HasGcFence", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.HasGcFence = bool(v != 0) case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field GcFence", wireType) } m.GcFence = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.GcFence |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccValue) 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 ErrIntOverflowKvrpcpb } 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: MvccValue: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccValue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccLock) 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 ErrIntOverflowKvrpcpb } 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: MvccLock: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccLock: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= (Op(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Primary = append(m.Primary[:0], dAtA[iNdEx:postIndex]...) if m.Primary == nil { m.Primary = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ShortValue", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ShortValue = append(m.ShortValue[:0], dAtA[iNdEx:postIndex]...) if m.ShortValue == nil { m.ShortValue = []byte{} } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForUpdateTs", wireType) } m.ForUpdateTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ForUpdateTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TxnSize", wireType) } m.TxnSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TxnSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UseAsyncCommit", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.UseAsyncCommit = bool(v != 0) case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Secondaries", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Secondaries = append(m.Secondaries, make([]byte, postIndex-iNdEx)) copy(m.Secondaries[len(m.Secondaries)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 10: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RollbackTs = append(m.RollbackTs, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RollbackTs = append(m.RollbackTs, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RollbackTs", wireType) } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *MvccInfo) 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 ErrIntOverflowKvrpcpb } 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: MvccInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MvccInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Lock == nil { m.Lock = &MvccLock{} } if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Writes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Writes = append(m.Writes, &MvccWrite{}) if err := m.Writes[len(m.Writes)-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 Values", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Values = append(m.Values, &MvccValue{}) if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *TxnInfo) 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 ErrIntOverflowKvrpcpb } 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: TxnInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TxnInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType) } m.Txn = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Txn |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Status |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *KeyRange) 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 ErrIntOverflowKvrpcpb } 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: KeyRange: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *LeaderInfo) 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 ErrIntOverflowKvrpcpb } 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: LeaderInfo: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LeaderInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) } m.PeerId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PeerId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReadState == nil { m.ReadState = &ReadState{} } if err := m.ReadState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *ReadState) 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 ErrIntOverflowKvrpcpb } 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: ReadState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType) } m.AppliedIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AppliedIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafeTs", wireType) } m.SafeTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafeTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckLeaderRequest) 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 ErrIntOverflowKvrpcpb } 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: CheckLeaderRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &LeaderInfo{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType) } m.Ts = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ts |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *CheckLeaderResponse) 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 ErrIntOverflowKvrpcpb } 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: CheckLeaderResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Regions = append(m.Regions, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType) } m.Ts = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ts |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *StoreSafeTSRequest) 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 ErrIntOverflowKvrpcpb } 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: StoreSafeTSRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreSafeTSRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.KeyRange == nil { m.KeyRange = &KeyRange{} } if err := m.KeyRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *StoreSafeTSResponse) 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 ErrIntOverflowKvrpcpb } 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: StoreSafeTSResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreSafeTSResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafeTs", wireType) } m.SafeTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafeTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawGetKeyTTLRequest) 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 ErrIntOverflowKvrpcpb } 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: RawGetKeyTTLRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawGetKeyTTLRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawGetKeyTTLResponse) 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 ErrIntOverflowKvrpcpb } 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: RawGetKeyTTLResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawGetKeyTTLResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotFound", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotFound = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawCASRequest) 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 ErrIntOverflowKvrpcpb } 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: RawCASRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawCASRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PreviousNotExist", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.PreviousNotExist = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PreviousValue", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PreviousValue = append(m.PreviousValue[:0], dAtA[iNdEx:postIndex]...) if m.PreviousValue == nil { m.PreviousValue = []byte{} } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ttl |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawCASResponse) 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 ErrIntOverflowKvrpcpb } 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: RawCASResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawCASResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Succeed", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Succeed = bool(v != 0) case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PreviousNotExist", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.PreviousNotExist = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PreviousValue", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.PreviousValue = append(m.PreviousValue[:0], dAtA[iNdEx:postIndex]...) if m.PreviousValue == nil { m.PreviousValue = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *GetLockWaitInfoRequest) 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 ErrIntOverflowKvrpcpb } 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: GetLockWaitInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetLockWaitInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *GetLockWaitInfoResponse) 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 ErrIntOverflowKvrpcpb } 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: GetLockWaitInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetLockWaitInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &deadlock.WaitForEntry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawCoprocessorRequest) 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 ErrIntOverflowKvrpcpb } 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: RawCoprocessorRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawCoprocessorRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CoprName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.CoprName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CoprVersionReq", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.CoprVersionReq = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-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 Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen 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 := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawCoprocessorResponse) 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 ErrIntOverflowKvrpcpb } 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: RawCoprocessorResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawCoprocessorResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: 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 ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + byteLen 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 := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawChecksumRequest) 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 ErrIntOverflowKvrpcpb } 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: RawChecksumRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawChecksumRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Context == nil { m.Context = &Context{} } if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Algorithm", wireType) } m.Algorithm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Algorithm |= (ChecksumAlgorithm(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ranges = append(m.Ranges, &KeyRange{}) if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 *RawChecksumResponse) 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 ErrIntOverflowKvrpcpb } 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: RawChecksumResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RawChecksumResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthKvrpcpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionError == nil { m.RegionError = &errorpb.Error{} } if err := m.RegionError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } 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 ErrInvalidLengthKvrpcpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Error = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType) } m.Checksum = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Checksum |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalKvs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowKvrpcpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TotalBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthKvrpcpb } 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 skipKvrpcpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowKvrpcpb } 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, ErrIntOverflowKvrpcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowKvrpcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthKvrpcpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowKvrpcpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipKvrpcpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthKvrpcpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowKvrpcpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptor_kvrpcpb_44115b53ffa2eeab) } var fileDescriptor_kvrpcpb_44115b53ffa2eeab = []byte{ // 4942 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3c, 0x5d, 0x8f, 0x24, 0xc9, 0x51, 0x5b, 0xfd, 0xdd, 0xd1, 0x3d, 0xdd, 0x35, 0x39, 0x33, 0x3b, 0xbd, 0xbb, 0x77, 0xb7, 0x73, 0x05, 0x7b, 0x3b, 0x37, 0xbe, 0x9b, 0xf5, 0x8d, 0xcf, 0x87, 0x01, 0x0b, 0xdf, 0xee, 0xcc, 0xee, 0xde, 0xdc, 0xce, 0xed, 0x8c, 0xaa, 0xdb, 0x7b, 0x9c, 0x84, 0x5d, 0xce, 0xad, 0xce, 0xee, 0x29, 0x75, 0x75, 0x55, 0x5d, 0x55, 0x76, 0xef, 0xb4, 0x2d, 0x24, 0xcc, 0x97, 0x84, 0x04, 0x18, 0x8c, 0xa5, 0xb3, 0x04, 0x42, 0xe2, 0xe1, 0x24, 0xe0, 0x8d, 0x37, 0x84, 0x04, 0x16, 0x12, 0x0f, 0xc6, 0x12, 0xb2, 0x1f, 0x11, 0x3c, 0x00, 0xc7, 0x0b, 0xfc, 0x00, 0x5e, 0x78, 0x42, 0xf9, 0x55, 0x1f, 0xdd, 0xbd, 0xb3, 0x73, 0xed, 0x99, 0xb5, 0xc5, 0xd3, 0x74, 0x46, 0x44, 0x65, 0x46, 0x44, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0e, 0x2c, 0x0d, 0xc6, 0x61, 0x60, 0x07, 0x8f, 0xb7, 0x83, 0xd0, 0xa7, 0x3e, 0x2a, 0xcb, 0xe6, 0xd5, 0xfa, 0x90, 0x50, 0xac, 0xc0, 0x57, 0x97, 0x48, 0x18, 0xfa, 0x61, 0xdc, 0x5c, 0xed, 0xfb, 0x7d, 0x9f, 0xff, 0xbc, 0xc5, 0x7e, 0x49, 0x68, 0x33, 0x1c, 0x45, 0x94, 0xff, 0x94, 0x80, 0x46, 0x97, 0xe0, 0xae, 0xeb, 0xdb, 0x03, 0xd5, 0x0b, 0x0d, 0xb1, 0x4d, 0x54, 0x2f, 0x46, 0x17, 0xe0, 0x3e, 0xa1, 0x26, 0xf9, 0x70, 0x44, 0x22, 0x8a, 0xb6, 0xa0, 0x6c, 0xfb, 0x1e, 0x25, 0x27, 0xb4, 0xa5, 0x6d, 0x68, 0x9b, 0xb5, 0x1d, 0x7d, 0x5b, 0xb1, 0xb6, 0x2b, 0xe0, 0xa6, 0x22, 0x40, 0x3a, 0xe4, 0x07, 0x64, 0xd2, 0xca, 0x6d, 0x68, 0x9b, 0x75, 0x93, 0xfd, 0x44, 0x2d, 0x28, 0x8f, 0x49, 0x18, 0x39, 0xbe, 0xd7, 0xca, 0x6f, 0x68, 0x9b, 0x05, 0x53, 0x35, 0x8d, 0x4f, 0x34, 0xa8, 0xf1, 0x61, 0xa2, 0xc0, 0xf7, 0x22, 0x82, 0xde, 0x80, 0x7a, 0x48, 0xfa, 0x8e, 0xef, 0x59, 0x5c, 0x26, 0x39, 0x58, 0x63, 0x5b, 0x49, 0x78, 0x97, 0xfd, 0x35, 0x6b, 0x82, 0x86, 0x37, 0xd0, 0x4d, 0x28, 0x0a, 0xda, 0x1c, 0xa7, 0x5d, 0x8e, 0x19, 0x7b, 0x40, 0x26, 0x82, 0x5c, 0xe0, 0xd1, 0x2a, 0x14, 0xc7, 0xd8, 0x1d, 0x11, 0xce, 0x43, 0xdd, 0x14, 0x0d, 0x74, 0x0d, 0xaa, 0x9e, 0x4f, 0xad, 0x9e, 0x3f, 0xf2, 0xba, 0xad, 0xc2, 0x86, 0xb6, 0x59, 0x31, 0x2b, 0x9e, 0x4f, 0xef, 0xb1, 0x36, 0xfa, 0x25, 0x68, 0x92, 0x13, 0x62, 0x5b, 0x5d, 0x42, 0xb1, 0xe3, 0x46, 0xd6, 0x78, 0xa7, 0x55, 0xe2, 0xa3, 0x5c, 0x8e, 0x47, 0xb9, 0x7b, 0x42, 0xec, 0x3d, 0x81, 0x7e, 0xb4, 0x63, 0x2e, 0x91, 0x74, 0xf3, 0xdd, 0x42, 0xa5, 0xa8, 0x97, 0x8c, 0xff, 0xd1, 0xa0, 0xd6, 0xb6, 0xb1, 0xb7, 0x88, 0x32, 0xaf, 0x41, 0x35, 0xa2, 0x38, 0xa4, 0x56, 0xa2, 0xd2, 0x0a, 0x07, 0x3c, 0x20, 0x13, 0x26, 0x91, 0xeb, 0x0c, 0x1d, 0xca, 0x25, 0x5a, 0x32, 0x45, 0x23, 0xad, 0xed, 0x42, 0x46, 0xdb, 0xe8, 0x0a, 0x54, 0x06, 0x64, 0x62, 0xf9, 0x9e, 0x3b, 0x69, 0x15, 0xb9, 0xa8, 0xe5, 0x01, 0x99, 0x1c, 0x7a, 0x2e, 0x9f, 0xa2, 0x90, 0x30, 0x3a, 0xc2, 0x25, 0xac, 0x98, 0xaa, 0x89, 0xd6, 0xa1, 0x4c, 0xbc, 0x2e, 0x1f, 0xbf, 0xcc, 0xc7, 0x2f, 0x11, 0xaf, 0xcb, 0x46, 0xbf, 0x0e, 0xb5, 0x08, 0x0f, 0x03, 0x97, 0x58, 0x11, 0x25, 0x41, 0xab, 0xc2, 0x79, 0x00, 0x01, 0x6a, 0x53, 0x12, 0x18, 0x7f, 0xa8, 0x41, 0x5d, 0xc8, 0xbd, 0xf8, 0xec, 0xde, 0x80, 0x62, 0x80, 0x9d, 0x30, 0x6a, 0xe5, 0x36, 0xf2, 0x9b, 0xb5, 0x9d, 0x66, 0x32, 0xbb, 0xe3, 0x23, 0xec, 0x84, 0xa6, 0xc0, 0x26, 0x46, 0x90, 0x3f, 0xdd, 0x08, 0x8c, 0xff, 0x2a, 0x40, 0xf3, 0x28, 0x24, 0x4f, 0x42, 0x87, 0x92, 0x45, 0xe6, 0xe3, 0x16, 0x54, 0x87, 0x23, 0x8a, 0xa9, 0xe3, 0x7b, 0x8a, 0xa7, 0x64, 0xb0, 0xf7, 0x24, 0xc6, 0x4c, 0x68, 0xd0, 0xcb, 0x50, 0x0f, 0x42, 0x67, 0x88, 0xc3, 0x89, 0xc5, 0x16, 0x9b, 0x34, 0xbe, 0x9a, 0x84, 0x1d, 0xf8, 0xf6, 0x00, 0xfd, 0x0c, 0x2c, 0x89, 0x39, 0xce, 0x4e, 0x5b, 0x9d, 0x03, 0x1f, 0x25, 0x73, 0xc7, 0xbe, 0xb7, 0x28, 0x75, 0xf9, 0xdc, 0x15, 0xcc, 0x32, 0x6b, 0x77, 0xa8, 0x8b, 0x76, 0x60, 0x2d, 0x1a, 0x38, 0x81, 0x65, 0xfb, 0x5e, 0x44, 0x43, 0xec, 0x78, 0xd4, 0xb2, 0x8f, 0x89, 0x3d, 0x90, 0x33, 0xb9, 0xc2, 0x90, 0xbb, 0x31, 0x6e, 0x97, 0xa1, 0xd0, 0x36, 0xac, 0x38, 0x91, 0x15, 0x90, 0x28, 0x72, 0x86, 0x4e, 0x44, 0x1d, 0x5b, 0x70, 0x57, 0xde, 0xc8, 0x6f, 0x56, 0xcc, 0x65, 0x27, 0x3a, 0x4a, 0x30, 0x9c, 0xc7, 0x2b, 0x50, 0xa1, 0x27, 0x9e, 0x15, 0x39, 0x5f, 0x27, 0x7c, 0xa6, 0x0b, 0x66, 0x99, 0x9e, 0x78, 0x6d, 0xe7, 0xeb, 0x04, 0x19, 0xb0, 0xd4, 0xf3, 0x43, 0x6b, 0x14, 0x74, 0x31, 0x25, 0x16, 0x8d, 0x5a, 0x55, 0x8e, 0xaf, 0xf5, 0xfc, 0xf0, 0xcb, 0x1c, 0xd6, 0x89, 0x18, 0xcd, 0xd0, 0xf1, 0x2c, 0xdb, 0x1f, 0x0e, 0x1d, 0xca, 0x68, 0x40, 0xd0, 0x0c, 0x1d, 0x6f, 0x97, 0xc3, 0x3a, 0x11, 0xda, 0x04, 0x7d, 0x14, 0x11, 0x0b, 0x47, 0x13, 0xcf, 0x96, 0x94, 0xad, 0x1a, 0x97, 0xa0, 0x31, 0x8a, 0xc8, 0x6d, 0x06, 0x16, 0xb4, 0x68, 0x03, 0x6a, 0x11, 0xb1, 0x7d, 0xaf, 0x8b, 0x43, 0x87, 0x44, 0xad, 0xfa, 0x46, 0x9e, 0xa9, 0x34, 0x05, 0x42, 0x2f, 0x00, 0xd0, 0x90, 0x59, 0x3a, 0xb1, 0x02, 0xbb, 0xb5, 0x24, 0x96, 0x35, 0x0d, 0x27, 0x87, 0x1e, 0x39, 0xb2, 0x39, 0x37, 0xf8, 0x24, 0xc5, 0x4d, 0x43, 0x72, 0x83, 0x4f, 0x62, 0x6e, 0xde, 0x86, 0x26, 0x8e, 0x22, 0x12, 0xb2, 0x59, 0xb4, 0x5c, 0x32, 0x26, 0x6e, 0xab, 0xb9, 0xa1, 0x6d, 0x36, 0x76, 0xd6, 0xe3, 0xe9, 0xbe, 0xad, 0xf0, 0x07, 0x0c, 0x6d, 0x36, 0x70, 0xa6, 0x6d, 0xfc, 0xad, 0x06, 0x7a, 0x62, 0x6a, 0x8b, 0x2f, 0x81, 0x57, 0xa1, 0xc4, 0xb1, 0xb3, 0xf6, 0x16, 0x1b, 0xb7, 0x24, 0x98, 0x55, 0x73, 0x7e, 0x56, 0xcd, 0x37, 0x41, 0x17, 0x6a, 0x49, 0x91, 0x09, 0x83, 0x5b, 0xf2, 0x99, 0x76, 0x14, 0xa1, 0xf1, 0xc3, 0x3c, 0x5c, 0x9e, 0x32, 0x83, 0xff, 0x2f, 0x2b, 0x66, 0xc6, 0x64, 0x4b, 0x73, 0x4d, 0xd6, 0x89, 0xac, 0x9e, 0x13, 0x46, 0x54, 0xad, 0x0d, 0x66, 0x45, 0x35, 0x27, 0xba, 0xc7, 0x60, 0x9c, 0x8f, 0x97, 0xa1, 0xfe, 0x04, 0x33, 0x15, 0x3a, 0x43, 0xe2, 0x8f, 0x28, 0x5f, 0x19, 0x79, 0xb3, 0xc6, 0x60, 0x1d, 0x01, 0x42, 0x2d, 0x28, 0xf6, 0xfc, 0xd0, 0x26, 0x7c, 0x55, 0x54, 0xee, 0xe4, 0x5a, 0x9a, 0x29, 0x00, 0x4c, 0x88, 0x90, 0xd0, 0x51, 0xe8, 0x59, 0x7c, 0x27, 0x12, 0x6b, 0xa2, 0x62, 0xd6, 0x05, 0xf0, 0x11, 0x87, 0xcd, 0xce, 0x68, 0x6d, 0xde, 0x8c, 0x36, 0xf9, 0x7a, 0xb7, 0xc8, 0x89, 0x13, 0x51, 0xe2, 0xd9, 0xa4, 0x55, 0x17, 0xeb, 0x86, 0x83, 0xef, 0x2a, 0xa8, 0xf1, 0xdf, 0x1a, 0xac, 0xcf, 0xcc, 0xe8, 0x73, 0x31, 0xcc, 0xeb, 0x50, 0x9d, 0x32, 0x4a, 0xae, 0x89, 0x8a, 0xad, 0x64, 0x68, 0xa9, 0xcd, 0x99, 0xcd, 0x64, 0x5d, 0xa8, 0x49, 0x6c, 0xd0, 0x97, 0xa1, 0x24, 0xf5, 0x53, 0xe4, 0xeb, 0x5c, 0xb6, 0xd0, 0x8b, 0x00, 0xf1, 0xc6, 0xcd, 0x26, 0x90, 0x39, 0xae, 0xaa, 0xda, 0xb9, 0x23, 0xe3, 0x63, 0x0d, 0xae, 0xa6, 0x64, 0x35, 0x7d, 0xd7, 0x7d, 0x8c, 0x17, 0xb3, 0xe0, 0x19, 0x6b, 0xcb, 0xcd, 0xb1, 0xb6, 0x19, 0x93, 0xca, 0xcf, 0x9a, 0x14, 0x82, 0xc2, 0x80, 0x4c, 0xd8, 0x72, 0x63, 0x82, 0xf0, 0xdf, 0xc6, 0x37, 0xe0, 0xda, 0x5c, 0x36, 0x9f, 0xc7, 0xb4, 0x18, 0x7f, 0xa5, 0xc1, 0x4a, 0xe7, 0xc4, 0x7b, 0x87, 0xe0, 0x90, 0xde, 0x21, 0x78, 0xa1, 0x70, 0x6f, 0x7a, 0xb9, 0xe6, 0xce, 0xb0, 0x5c, 0xf3, 0x73, 0x14, 0xf8, 0x0a, 0x34, 0x71, 0x77, 0xec, 0x44, 0xc4, 0x8a, 0x57, 0xad, 0x74, 0x4b, 0x02, 0x7c, 0x20, 0xd6, 0xae, 0xf1, 0x7b, 0x1a, 0xac, 0x66, 0x79, 0x7e, 0x0e, 0xb1, 0x63, 0xda, 0x97, 0xe4, 0x33, 0xbe, 0xc4, 0xf8, 0x8f, 0x1c, 0xac, 0xf1, 0x3d, 0xb5, 0x73, 0xe2, 0xb5, 0x29, 0xa6, 0xa3, 0x68, 0x11, 0x2d, 0x5e, 0x07, 0xa5, 0xb1, 0x54, 0xa4, 0x07, 0x12, 0xc4, 0xa2, 0xad, 0x75, 0x28, 0x0b, 0x0e, 0x94, 0x65, 0x95, 0x38, 0x03, 0x11, 0xd3, 0x9b, 0x8d, 0x5d, 0x97, 0x84, 0x96, 0xd0, 0x71, 0xe2, 0xce, 0x05, 0xb8, 0xcd, 0xa0, 0x1d, 0xbe, 0x5e, 0xec, 0x51, 0x18, 0x12, 0x8f, 0x93, 0x08, 0x87, 0x58, 0x95, 0x90, 0x4e, 0x84, 0xde, 0x80, 0xb5, 0x50, 0x1a, 0x9f, 0xe5, 0xf4, 0x2c, 0xb6, 0xb4, 0xb8, 0x3b, 0x91, 0x41, 0x04, 0x52, 0xc8, 0xfd, 0xde, 0x43, 0x9f, 0x72, 0x97, 0x82, 0xb6, 0x60, 0x99, 0x7b, 0x32, 0x2b, 0xbd, 0x63, 0x0b, 0x2f, 0xd9, 0xe4, 0x88, 0x76, 0xb2, 0x65, 0x7f, 0x11, 0xae, 0x86, 0x24, 0xf2, 0xdd, 0xb1, 0xe3, 0xf5, 0x67, 0xc3, 0x8e, 0x0a, 0xff, 0xa8, 0x15, 0x53, 0x4c, 0x39, 0x29, 0xe3, 0x5b, 0x39, 0xb8, 0x3c, 0xad, 0xe3, 0x9f, 0xe8, 0xac, 0xa3, 0x1b, 0xd0, 0x90, 0x0e, 0x2d, 0xbb, 0x05, 0x2d, 0x09, 0xa8, 0x32, 0xea, 0x9b, 0x50, 0xc2, 0x36, 0xdb, 0xd6, 0xb8, 0xc2, 0x1b, 0xa9, 0xf8, 0xf5, 0x36, 0x07, 0x9b, 0x12, 0x8d, 0xb6, 0xa1, 0xca, 0x87, 0x72, 0xbc, 0x9e, 0x2f, 0xcf, 0x18, 0x09, 0x5f, 0x4c, 0x07, 0xfb, 0x5e, 0xcf, 0x37, 0x39, 0x3b, 0xec, 0x97, 0xf1, 0x4d, 0x0d, 0xae, 0x72, 0x8d, 0xb4, 0x65, 0xd4, 0xc3, 0x57, 0xda, 0x42, 0xa6, 0xa7, 0xbc, 0x52, 0x2e, 0xf1, 0x4a, 0x67, 0x5a, 0xb1, 0xc6, 0xf7, 0x34, 0xb8, 0x36, 0x97, 0x87, 0xe7, 0x30, 0x35, 0x37, 0xa1, 0xc8, 0x74, 0xc1, 0x16, 0x43, 0x7e, 0xbe, 0xae, 0x04, 0x9e, 0x1d, 0xa0, 0xa6, 0xe3, 0x9c, 0x78, 0xd7, 0x31, 0xfe, 0x42, 0x83, 0x25, 0x61, 0xa0, 0x17, 0xb6, 0x2f, 0x28, 0xed, 0xe6, 0x53, 0xda, 0x3d, 0x9b, 0xf1, 0x88, 0xd3, 0xa3, 0x59, 0x7a, 0xec, 0x78, 0xae, 0xdf, 0x37, 0xfe, 0x48, 0x83, 0x86, 0xe2, 0xf5, 0x39, 0x28, 0x78, 0x96, 0xc7, 0xfc, 0x1c, 0x1e, 0x8d, 0x3e, 0x2c, 0xed, 0x0f, 0x03, 0x3f, 0x8c, 0x15, 0x98, 0x09, 0xf7, 0xb4, 0x33, 0x84, 0x7b, 0xb3, 0x03, 0xe5, 0xe6, 0x0d, 0xf4, 0x01, 0x34, 0xd4, 0x40, 0x8b, 0x4b, 0xbf, 0x9a, 0x96, 0xbe, 0xaa, 0xce, 0x84, 0xdf, 0x66, 0x9a, 0x75, 0x09, 0xf6, 0x46, 0xc1, 0xf9, 0xe4, 0x3b, 0xce, 0xb4, 0xdf, 0x65, 0xfd, 0x71, 0x61, 0xca, 0x1f, 0x1b, 0xdf, 0xd1, 0xa0, 0x19, 0x33, 0xf5, 0xd3, 0x33, 0xdf, 0x03, 0x68, 0xde, 0xc1, 0xd4, 0x3e, 0x5e, 0x30, 0x37, 0x34, 0xcf, 0xd7, 0x3c, 0x3d, 0x3b, 0xf4, 0xaf, 0x1a, 0xe8, 0xc9, 0x68, 0x17, 0x9e, 0x44, 0x98, 0x93, 0xed, 0x29, 0x7c, 0x8a, 0x6c, 0x4f, 0xa2, 0xeb, 0xe2, 0xe9, 0xba, 0x7e, 0xb7, 0x50, 0xc9, 0xeb, 0x05, 0xe3, 0x1b, 0xb0, 0xca, 0x85, 0xbb, 0xf0, 0xd0, 0x74, 0x8e, 0x0b, 0x32, 0x22, 0x58, 0x9b, 0x1a, 0xfc, 0xe2, 0x6d, 0xcc, 0xf8, 0x4b, 0x0d, 0x9a, 0x6d, 0x1b, 0x7b, 0x8b, 0x1e, 0x25, 0xaf, 0x03, 0x3b, 0xa2, 0x4f, 0xc9, 0x0a, 0x43, 0x7c, 0xa2, 0x24, 0xcd, 0x64, 0xcb, 0xf2, 0x4f, 0xcb, 0x96, 0x15, 0xd2, 0xd9, 0xb2, 0x54, 0x7a, 0xab, 0x98, 0x4e, 0x6f, 0x19, 0x1f, 0x69, 0xa0, 0x27, 0xcc, 0xfe, 0x14, 0x6d, 0x69, 0xc6, 0x0f, 0x35, 0x40, 0x26, 0x0f, 0x95, 0xc8, 0xa2, 0x9a, 0x3c, 0x93, 0xdd, 0x9c, 0xcd, 0x25, 0xa0, 0xd7, 0xa1, 0x4a, 0x4f, 0x3c, 0x1e, 0xb9, 0x88, 0xa3, 0x4d, 0x7a, 0xe4, 0xce, 0x89, 0x27, 0x22, 0x17, 0x2a, 0x7e, 0x24, 0x87, 0xa0, 0x62, 0xca, 0x1a, 0x3f, 0x84, 0x95, 0x8c, 0x40, 0xcf, 0xc1, 0x16, 0x1f, 0x41, 0xf5, 0xfe, 0xee, 0x22, 0xaa, 0x7b, 0x11, 0x20, 0xc2, 0x3d, 0x62, 0x05, 0xbe, 0xe3, 0x51, 0xa9, 0xb7, 0x2a, 0x83, 0x1c, 0x31, 0x80, 0x71, 0x0c, 0xc0, 0xfa, 0x7d, 0x0e, 0x12, 0x7c, 0xa4, 0x01, 0xda, 0x23, 0x2e, 0xa1, 0xc4, 0xc4, 0x5e, 0x9f, 0x9c, 0x7b, 0x76, 0x39, 0xb5, 0x32, 0xf2, 0xd3, 0x89, 0x5f, 0xcf, 0xa7, 0x4e, 0x4f, 0x66, 0x92, 0x45, 0xd2, 0x1c, 0x04, 0xe8, 0xd0, 0x73, 0x27, 0xc6, 0x57, 0x61, 0x25, 0xc3, 0xd8, 0x79, 0x6f, 0xd8, 0x5f, 0x81, 0x25, 0x13, 0x3f, 0x39, 0xb7, 0xeb, 0x89, 0x06, 0xe4, 0xec, 0x1e, 0x97, 0xb1, 0x6a, 0xe6, 0xec, 0x9e, 0xf1, 0xbb, 0x1a, 0x34, 0x54, 0xff, 0xe7, 0xcc, 0xfa, 0x02, 0x97, 0x10, 0x46, 0x17, 0x90, 0x89, 0x9f, 0x9c, 0xf7, 0xae, 0x3b, 0x2d, 0xb4, 0x0f, 0x2b, 0x99, 0x51, 0x2e, 0x7a, 0xb7, 0x35, 0xfe, 0x54, 0xe3, 0xb3, 0x78, 0x34, 0x3a, 0xa7, 0x59, 0x9c, 0xaf, 0x59, 0x21, 0x66, 0x41, 0x89, 0xc9, 0xbe, 0x4b, 0xf2, 0x81, 0xec, 0x27, 0x33, 0xf3, 0x9e, 0x1f, 0x5a, 0x36, 0x8e, 0xe4, 0x51, 0xb7, 0xd4, 0xf3, 0xc3, 0x5d, 0x1c, 0xb1, 0x88, 0x53, 0xf1, 0x77, 0xde, 0x06, 0xfc, 0x37, 0x5a, 0x32, 0xa7, 0x0b, 0x2a, 0xe0, 0x8c, 0x31, 0xcd, 0xd4, 0x34, 0xa3, 0x55, 0x21, 0x7f, 0x21, 0x4e, 0xc1, 0x4d, 0xeb, 0xa0, 0x98, 0xd6, 0x01, 0xb3, 0x1c, 0x4a, 0x5d, 0x91, 0x5e, 0x2b, 0x98, 0xfc, 0x37, 0x5b, 0xdd, 0x19, 0xde, 0xcf, 0x5b, 0x39, 0x13, 0xd0, 0x4d, 0xfc, 0x44, 0x3a, 0x90, 0x8b, 0x58, 0xe0, 0x69, 0x71, 0x0b, 0x99, 0x29, 0xff, 0x15, 0x58, 0x4e, 0x0d, 0x7d, 0xde, 0x82, 0xfd, 0x9a, 0x06, 0x6b, 0x4a, 0x73, 0x8b, 0x8b, 0x77, 0x86, 0xc5, 0xfc, 0x74, 0x01, 0x31, 0x5c, 0x9e, 0xe6, 0xe0, 0xbc, 0xa5, 0xfc, 0x27, 0xe1, 0x3d, 0x9f, 0xe3, 0x85, 0x67, 0xfa, 0x5a, 0xb3, 0x90, 0xbd, 0xd6, 0x14, 0x8a, 0x29, 0xc6, 0x8a, 0xf9, 0xf4, 0xd7, 0x9c, 0x46, 0x1f, 0x9a, 0xb1, 0x38, 0x8b, 0xeb, 0xea, 0x65, 0xc8, 0x0f, 0xc6, 0x4f, 0x5d, 0xac, 0x0c, 0x67, 0xfc, 0x8e, 0x30, 0x8f, 0x9f, 0xc8, 0x96, 0x3e, 0xe5, 0x26, 0xa5, 0x9d, 0x5c, 0xe8, 0x26, 0xfe, 0x23, 0x2d, 0xf1, 0x23, 0x8b, 0x1a, 0xcb, 0xab, 0x50, 0x0a, 0x19, 0x77, 0x73, 0x53, 0xdd, 0x82, 0x6f, 0x49, 0xc0, 0xc2, 0x36, 0x82, 0xed, 0x63, 0x2b, 0x6d, 0x3f, 0x55, 0x06, 0x39, 0x38, 0x37, 0x1b, 0x32, 0x5c, 0x58, 0xcd, 0x4a, 0x74, 0xa1, 0xf6, 0xf2, 0xab, 0x70, 0xe5, 0xcb, 0x1e, 0x0b, 0x3c, 0xf7, 0x48, 0x44, 0x43, 0x7f, 0xf2, 0x7c, 0x4d, 0xc6, 0x20, 0x70, 0x75, 0xde, 0xf0, 0xe7, 0x6d, 0x26, 0x5f, 0x83, 0x6b, 0x26, 0xe9, 0x3b, 0x11, 0x25, 0x21, 0x3b, 0x1b, 0x1c, 0x3e, 0x8e, 0x48, 0x38, 0x26, 0xe1, 0x22, 0x72, 0xae, 0x41, 0x89, 0x1d, 0x1f, 0x69, 0x24, 0xa3, 0xf6, 0xe2, 0x10, 0x9f, 0x74, 0x22, 0xe3, 0x4d, 0x78, 0x61, 0xfe, 0x08, 0x52, 0x94, 0x98, 0x2f, 0x2d, 0x1b, 0x83, 0xb6, 0x78, 0xee, 0xf3, 0x82, 0x98, 0x1a, 0xc1, 0x95, 0x39, 0xdd, 0x9f, 0xc6, 0x11, 0x33, 0x61, 0x27, 0xb2, 0x6c, 0x97, 0x60, 0x71, 0x9c, 0xab, 0x98, 0x65, 0x27, 0xe2, 0x29, 0xa4, 0xb3, 0x1f, 0x2d, 0xbf, 0x0a, 0x57, 0x4c, 0x32, 0xf4, 0xc5, 0x39, 0xec, 0x02, 0xc4, 0xda, 0x81, 0xab, 0xf3, 0xfa, 0x3f, 0x55, 0xd3, 0xdf, 0xd2, 0x60, 0xfd, 0xe8, 0x78, 0x12, 0x39, 0x36, 0x76, 0x7f, 0x9c, 0xec, 0xc1, 0x7c, 0x96, 0x16, 0xc8, 0x19, 0x18, 0x1f, 0x40, 0x6b, 0x96, 0xa1, 0x53, 0xe7, 0x26, 0x9e, 0x80, 0xdc, 0x33, 0x26, 0xe0, 0x4f, 0x34, 0x40, 0xed, 0xc0, 0x75, 0xa8, 0xc9, 0x57, 0xc6, 0x62, 0x59, 0x92, 0x6a, 0xc4, 0x7a, 0x48, 0x96, 0xb3, 0xb8, 0x6b, 0xe5, 0x40, 0x26, 0x14, 0x3b, 0xc1, 0x2a, 0x02, 0x95, 0x15, 0xaa, 0x2a, 0x6c, 0x84, 0xae, 0x42, 0xd5, 0x89, 0xac, 0x10, 0x3f, 0xb1, 0x06, 0x63, 0xe5, 0x0b, 0x9d, 0xc8, 0xc4, 0x4f, 0x1e, 0x8c, 0x8d, 0x7f, 0xd0, 0x60, 0x25, 0xc3, 0xde, 0xe2, 0xcb, 0xfd, 0x15, 0x28, 0xb8, 0xa4, 0x47, 0xe5, 0x31, 0xb7, 0xb1, 0x2d, 0x4b, 0xda, 0x44, 0xc7, 0x9c, 0x63, 0x8e, 0x47, 0x9b, 0x50, 0x0c, 0x9d, 0xfe, 0x31, 0x95, 0xa5, 0x3d, 0xf3, 0x08, 0x05, 0x01, 0xda, 0x64, 0x8e, 0xb9, 0xcf, 0x13, 0xcf, 0x22, 0x0d, 0x31, 0x45, 0x6b, 0x2a, 0xb4, 0xf1, 0x9b, 0x1a, 0xe8, 0x26, 0xc1, 0xdd, 0x7d, 0xaf, 0x4b, 0x4e, 0x16, 0xd1, 0xf1, 0x15, 0xa8, 0xc4, 0xb7, 0x6d, 0xc2, 0x9a, 0xca, 0x91, 0xbc, 0x67, 0x4b, 0xf6, 0xa4, 0xfc, 0x33, 0xf6, 0x24, 0xe3, 0x0f, 0x34, 0x58, 0x4e, 0xb1, 0xb1, 0xb8, 0x2e, 0x5f, 0x04, 0x08, 0x09, 0xee, 0x5a, 0x0e, 0xeb, 0x48, 0xe5, 0x24, 0x42, 0xd5, 0x33, 0x63, 0x89, 0x59, 0x17, 0xe9, 0xce, 0x94, 0x47, 0xc5, 0xe6, 0x27, 0x09, 0x8c, 0x36, 0xac, 0xbc, 0x37, 0xb6, 0xed, 0xfb, 0x84, 0xde, 0x99, 0x30, 0x7e, 0xcf, 0x23, 0xfe, 0x36, 0x7e, 0x5b, 0x83, 0xd5, 0x6c, 0xaf, 0xe7, 0x7d, 0xac, 0xbe, 0x01, 0x05, 0x7e, 0x73, 0x36, 0x2d, 0x1f, 0x1b, 0x95, 0xcb, 0xc7, 0xd1, 0xc6, 0xd7, 0x60, 0x3d, 0xe6, 0x43, 0xde, 0x8b, 0x9e, 0xef, 0xec, 0xb3, 0xf5, 0xdb, 0x9a, 0x1d, 0xe2, 0xbc, 0xc5, 0x95, 0x2a, 0xce, 0x27, 0x47, 0x1c, 0xa5, 0x80, 0xc2, 0xe9, 0x0a, 0xf8, 0xbb, 0x32, 0x94, 0x77, 0x93, 0x6d, 0x5f, 0x72, 0xe3, 0x74, 0x39, 0x2b, 0x05, 0xb3, 0x22, 0x00, 0xfb, 0x5d, 0xf4, 0x56, 0xc2, 0x6a, 0xe0, 0xdb, 0xc7, 0x72, 0x95, 0xae, 0x64, 0x17, 0xd4, 0x5d, 0x86, 0x8a, 0xf9, 0x65, 0x0d, 0xb4, 0x01, 0x85, 0x80, 0x10, 0x55, 0x87, 0x57, 0x57, 0xf4, 0x47, 0x84, 0x84, 0x26, 0xc7, 0xf0, 0x23, 0x25, 0x09, 0x87, 0xf2, 0x08, 0xce, 0x7f, 0xa3, 0x5b, 0x50, 0x09, 0x42, 0xc7, 0x0f, 0x1d, 0x3a, 0xe1, 0x31, 0x55, 0x63, 0x67, 0x25, 0xa5, 0xfd, 0xe1, 0x10, 0x7b, 0xdd, 0xa3, 0xd0, 0x31, 0x63, 0x22, 0xf4, 0x36, 0x34, 0x9d, 0xc8, 0x77, 0x71, 0xaa, 0x3a, 0xab, 0x3c, 0x55, 0x9d, 0xb5, 0xaf, 0xf0, 0xb2, 0x3a, 0xcb, 0xc9, 0xb4, 0xd1, 0xcf, 0x42, 0x83, 0xa7, 0x5c, 0x1c, 0xd7, 0xb5, 0x6c, 0x6c, 0x1f, 0x13, 0x79, 0x09, 0x5d, 0xf7, 0x7c, 0x7a, 0xcf, 0x71, 0xdd, 0x5d, 0x06, 0xe3, 0x33, 0x3d, 0xf1, 0x6c, 0xcb, 0xf5, 0xfb, 0xa2, 0x80, 0xc7, 0x2c, 0xb3, 0xf6, 0x81, 0xdf, 0x47, 0x9b, 0xa0, 0x87, 0xc4, 0xf6, 0xc3, 0x2e, 0xaf, 0xfe, 0xb1, 0x22, 0x8a, 0xa9, 0xac, 0xe0, 0x69, 0x08, 0x78, 0xc7, 0x19, 0x92, 0x36, 0xc5, 0x34, 0x45, 0x19, 0xd9, 0xd8, 0x13, 0x94, 0xb5, 0x34, 0x25, 0xdb, 0x44, 0x38, 0xe5, 0xcb, 0x4c, 0xeb, 0x81, 0xeb, 0xd8, 0xd8, 0x62, 0xab, 0x57, 0x96, 0xf1, 0xd4, 0x24, 0x8c, 0xb9, 0x0a, 0x74, 0x03, 0x1a, 0xe2, 0x9a, 0x9c, 0x74, 0x2d, 0xb1, 0xa5, 0x2c, 0xf1, 0xb3, 0xf9, 0x92, 0x82, 0xf2, 0x3b, 0x58, 0xf4, 0xf3, 0x70, 0x85, 0x6d, 0x76, 0xe4, 0x84, 0xd8, 0x23, 0xae, 0xa4, 0xee, 0x28, 0x14, 0xda, 0x1a, 0xaa, 0x72, 0xb7, 0xcb, 0x43, 0x7c, 0x72, 0x57, 0xe1, 0xf7, 0x24, 0xfa, 0x3d, 0x7e, 0xf7, 0x8b, 0x83, 0xc0, 0x75, 0x88, 0xf2, 0x27, 0x4d, 0x91, 0x1b, 0x96, 0x40, 0xe1, 0x52, 0xd6, 0xa1, 0x4c, 0x71, 0x34, 0x60, 0xa6, 0xa3, 0x8b, 0x72, 0x04, 0xd6, 0xdc, 0xef, 0xf2, 0xcd, 0x85, 0x62, 0x97, 0x08, 0x01, 0x96, 0xb9, 0x00, 0x55, 0x0e, 0xe1, 0xec, 0xbf, 0x06, 0x88, 0x31, 0x3a, 0x0a, 0x6d, 0x62, 0xf5, 0x43, 0x7f, 0x14, 0x58, 0x14, 0xf7, 0x5b, 0x88, 0x1b, 0xb2, 0xae, 0x30, 0xf7, 0x19, 0xa2, 0x83, 0xfb, 0xe8, 0x0b, 0xb0, 0xd4, 0x75, 0xa2, 0x81, 0xd5, 0x1b, 0xb9, 0xae, 0xe5, 0x07, 0xb4, 0xb5, 0xc2, 0x27, 0x79, 0x35, 0x9e, 0xe4, 0x3d, 0x27, 0x1a, 0xdc, 0x1b, 0xb9, 0xee, 0x61, 0x40, 0xcd, 0x5a, 0x37, 0x69, 0x30, 0x9d, 0xb3, 0x4d, 0x8c, 0xd0, 0x70, 0x62, 0x85, 0x62, 0x89, 0xb7, 0x56, 0x85, 0xce, 0x9d, 0xc8, 0x64, 0x60, 0xb5, 0xf0, 0xdf, 0x84, 0x1a, 0x0e, 0x9c, 0x38, 0xc5, 0xbd, 0x36, 0x65, 0x7e, 0xb7, 0x8f, 0xf6, 0x65, 0xa2, 0xdb, 0x04, 0x1c, 0x38, 0xc9, 0xc5, 0x7e, 0x53, 0x64, 0xc1, 0x69, 0x3c, 0x0f, 0x97, 0xf9, 0x3c, 0x34, 0x62, 0xb0, 0x98, 0x88, 0x5f, 0x00, 0x51, 0x58, 0x6d, 0x29, 0xef, 0xb2, 0xce, 0x57, 0xc6, 0xda, 0xb6, 0x2a, 0xb7, 0xee, 0xb0, 0xbf, 0xca, 0xc5, 0xd4, 0x69, 0xaa, 0xf5, 0x6e, 0xa1, 0x52, 0xd0, 0x8b, 0x6c, 0xfa, 0x71, 0xd7, 0xfa, 0x70, 0xe4, 0x87, 0xa3, 0xa1, 0xf1, 0x6f, 0x39, 0xa8, 0x28, 0xa7, 0x3d, 0x53, 0x7a, 0xa3, 0xcd, 0x96, 0xde, 0xbc, 0x0c, 0x75, 0x5e, 0x57, 0x90, 0xcd, 0xf3, 0xd7, 0x18, 0x4c, 0x89, 0x32, 0xeb, 0x4c, 0xd2, 0x75, 0x0f, 0x85, 0x6c, 0xdd, 0x43, 0xba, 0x0e, 0xb4, 0x98, 0xad, 0x03, 0xdd, 0x94, 0x25, 0x0c, 0x74, 0x12, 0x10, 0xb9, 0x8a, 0x6b, 0xb1, 0x1a, 0x0f, 0x03, 0x51, 0xbc, 0xd0, 0x99, 0x04, 0x04, 0x7d, 0x06, 0x10, 0xa7, 0xcc, 0x16, 0x4c, 0x95, 0x79, 0x77, 0x4d, 0x86, 0xb9, 0x97, 0x2a, 0x9a, 0x9a, 0x57, 0x16, 0x5a, 0x99, 0x5b, 0x16, 0x3a, 0x53, 0x2b, 0x57, 0x9d, 0xad, 0x95, 0x9b, 0x2a, 0x1d, 0x85, 0x99, 0xd2, 0x51, 0xe3, 0xa3, 0x02, 0x54, 0x54, 0xaa, 0x3d, 0xb5, 0x73, 0x6a, 0xcf, 0xd8, 0x39, 0xd1, 0x0b, 0xcc, 0x9d, 0xd2, 0x70, 0x82, 0x1f, 0xbb, 0x44, 0x7a, 0xeb, 0x04, 0xc0, 0xfc, 0x38, 0x7e, 0xec, 0x87, 0x54, 0x26, 0x69, 0x44, 0x03, 0xed, 0x40, 0xc5, 0xf6, 0xbd, 0x9e, 0xeb, 0xd8, 0x74, 0xe6, 0xaa, 0xf1, 0xfd, 0xd0, 0xa1, 0xcc, 0x12, 0x38, 0xd6, 0x8c, 0xe9, 0x98, 0x41, 0x61, 0x97, 0x99, 0xc4, 0x44, 0x16, 0xe8, 0x14, 0xa5, 0x41, 0xc5, 0x16, 0x2b, 0xb0, 0xbc, 0x46, 0xc7, 0xac, 0xe3, 0x54, 0x0b, 0xbd, 0x0e, 0x15, 0x55, 0xf5, 0x3f, 0x53, 0x64, 0xb2, 0x27, 0x11, 0x66, 0x4c, 0x82, 0xf6, 0x60, 0x39, 0x56, 0xa6, 0x45, 0x4e, 0x02, 0x27, 0x24, 0x5d, 0x3e, 0x4d, 0xb5, 0x9d, 0x56, 0xc6, 0x3f, 0x33, 0xd5, 0xde, 0x15, 0x78, 0xb3, 0x69, 0x67, 0x01, 0x6c, 0x11, 0x33, 0x93, 0x49, 0x12, 0xdc, 0x15, 0xde, 0xc3, 0x6a, 0xfa, 0x8e, 0xe8, 0xa1, 0x4c, 0x76, 0x9b, 0x35, 0x9a, 0x34, 0xd0, 0x3b, 0xb0, 0x92, 0x8c, 0x4f, 0x7d, 0xdf, 0x72, 0x71, 0xd8, 0x17, 0x95, 0x94, 0xb5, 0x9d, 0x2b, 0x33, 0x1c, 0x74, 0x7c, 0xff, 0x80, 0x11, 0x98, 0xba, 0x3d, 0x05, 0x41, 0xbb, 0xa0, 0x27, 0xd5, 0xbc, 0x3d, 0xec, 0xb8, 0xa4, 0xcb, 0x9d, 0x75, 0x5a, 0x90, 0xb8, 0x9c, 0xf7, 0x1e, 0xc7, 0x9b, 0x49, 0xfd, 0xaf, 0x00, 0x18, 0x1f, 0x6b, 0xb0, 0x94, 0x99, 0x95, 0x4c, 0x20, 0xa0, 0x65, 0xc3, 0xc0, 0xeb, 0x50, 0x53, 0x53, 0x96, 0x84, 0x09, 0xa0, 0x40, 0x9d, 0x68, 0xce, 0xb2, 0x6b, 0x41, 0x59, 0x2e, 0x5d, 0x51, 0x05, 0x69, 0xaa, 0x26, 0xf3, 0x9a, 0x71, 0x67, 0x89, 0x79, 0x8b, 0xf5, 0xa7, 0x2b, 0x4c, 0x5c, 0xb8, 0xbb, 0x01, 0xf5, 0xb4, 0x0d, 0xa8, 0x91, 0xb4, 0x24, 0x20, 0xfb, 0x33, 0x0d, 0x2a, 0x6a, 0xbe, 0xd3, 0x95, 0x65, 0x5a, 0xa6, 0xb2, 0x4c, 0xb9, 0x81, 0x24, 0x9a, 0xe3, 0x84, 0xec, 0x08, 0xb1, 0x05, 0xcb, 0xca, 0x4a, 0x18, 0xda, 0x3a, 0xc6, 0xd1, 0xb1, 0xbc, 0x1d, 0x6c, 0x2a, 0xc4, 0x03, 0x32, 0x79, 0x07, 0x47, 0xc7, 0xe8, 0xf3, 0x00, 0xbc, 0x48, 0xd6, 0x3e, 0xc6, 0x8e, 0x27, 0x23, 0xf3, 0xcb, 0xdb, 0xf1, 0xeb, 0x93, 0xf7, 0xb1, 0x43, 0xef, 0xf9, 0xe1, 0x5d, 0x8f, 0xf9, 0xe4, 0x2a, 0xa3, 0xdc, 0x65, 0x84, 0xc6, 0xb7, 0x35, 0x68, 0x4e, 0xd9, 0xd6, 0x69, 0xfa, 0xde, 0x86, 0x15, 0x4c, 0x29, 0x19, 0x06, 0xcc, 0x21, 0x27, 0x3a, 0x12, 0x7a, 0x5f, 0x8e, 0x51, 0xb1, 0x23, 0x98, 0x55, 0xff, 0x8c, 0xfb, 0x28, 0xcc, 0xb8, 0x0f, 0x63, 0x1f, 0x6a, 0x29, 0x6b, 0x7d, 0xc6, 0xfc, 0x9f, 0x5a, 0xd0, 0x67, 0xdc, 0x02, 0x7d, 0xda, 0x70, 0xb3, 0xc5, 0x4a, 0xda, 0x54, 0xb1, 0xd2, 0x0f, 0x34, 0x68, 0x4e, 0xd9, 0xe8, 0x69, 0x0c, 0xcc, 0xa6, 0xc1, 0x3f, 0x0b, 0xd5, 0xd8, 0xa4, 0xb9, 0xe0, 0x8d, 0x1d, 0x34, 0x6b, 0xfd, 0x66, 0x42, 0xc4, 0xa6, 0x99, 0xfb, 0x18, 0xc7, 0xeb, 0x4f, 0x57, 0x17, 0x36, 0x15, 0x42, 0xd5, 0x17, 0xbe, 0x06, 0x28, 0xa6, 0x9d, 0xb1, 0x51, 0x85, 0x89, 0x15, 0xf9, 0x5d, 0x0d, 0x80, 0x05, 0x48, 0xa2, 0x7a, 0x02, 0xbd, 0x0a, 0xcb, 0xdc, 0x46, 0x9e, 0x60, 0xd7, 0x15, 0xf1, 0xd4, 0x50, 0x08, 0x94, 0x37, 0x1b, 0x0c, 0xf1, 0x3e, 0x76, 0x5d, 0x46, 0xfe, 0x5e, 0x84, 0x6e, 0xc1, 0x6a, 0x10, 0xfa, 0x36, 0x89, 0xa2, 0x2c, 0x75, 0x8e, 0x53, 0x2f, 0x4b, 0x5c, 0xea, 0x83, 0x6d, 0x58, 0x1d, 0x8c, 0x79, 0x38, 0x92, 0xfd, 0x20, 0xcf, 0x3f, 0xd0, 0x07, 0x63, 0x16, 0x98, 0x24, 0xf4, 0xc6, 0x57, 0xa0, 0xc2, 0x02, 0x32, 0xbe, 0xc3, 0xae, 0x42, 0x91, 0xfa, 0x14, 0xbb, 0x92, 0x17, 0xd1, 0x60, 0xae, 0x5e, 0x0e, 0x43, 0xba, 0x72, 0xdc, 0x04, 0x10, 0x1f, 0xc6, 0x1e, 0x4f, 0x28, 0x51, 0xa3, 0xf0, 0xc3, 0xd8, 0x1d, 0x06, 0x30, 0x7e, 0x43, 0x03, 0x60, 0xfd, 0x4b, 0xc9, 0x6f, 0x42, 0x91, 0xbf, 0x10, 0x98, 0xd9, 0x60, 0x14, 0x0f, 0xa6, 0xc0, 0xb3, 0x08, 0x3f, 0xae, 0xaf, 0x9d, 0x4b, 0xc7, 0xd1, 0x8c, 0xac, 0x8b, 0x29, 0x9e, 0x39, 0x09, 0x25, 0x64, 0x0c, 0x6d, 0xfc, 0x20, 0x2f, 0xde, 0xe6, 0x08, 0x2e, 0x1e, 0xed, 0xa0, 0xd7, 0x01, 0xc5, 0x22, 0xa8, 0x68, 0x41, 0xd9, 0xd4, 0x72, 0x8c, 0x91, 0x31, 0x03, 0xaf, 0xda, 0xe2, 0xba, 0x48, 0x48, 0x65, 0xd5, 0x16, 0x87, 0xc6, 0x64, 0x5f, 0x82, 0x17, 0x42, 0x16, 0x06, 0x75, 0x1f, 0x5b, 0x5d, 0x9e, 0x4c, 0xb6, 0xa2, 0x81, 0x13, 0x04, 0x7c, 0x89, 0x8e, 0x3c, 0x2a, 0x5d, 0xc6, 0x15, 0x49, 0x23, 0xf2, 0xcd, 0x6d, 0x41, 0xb1, 0xcb, 0x08, 0x58, 0x1c, 0xab, 0x3a, 0x60, 0x7e, 0x26, 0xfb, 0xb5, 0xb0, 0xc4, 0xcb, 0x92, 0xe0, 0x01, 0x99, 0x64, 0x3e, 0x7d, 0x1b, 0x5e, 0x54, 0x9f, 0x3e, 0xe6, 0x8e, 0x8a, 0x87, 0xf9, 0xd6, 0x31, 0x73, 0x45, 0xfc, 0xf3, 0x62, 0x66, 0xf0, 0x3b, 0x8c, 0x86, 0x47, 0xfd, 0xef, 0x38, 0x54, 0xf4, 0xf0, 0x73, 0xd0, 0xca, 0xf6, 0xc0, 0xe7, 0x55, 0x7c, 0x2c, 0x5e, 0x0c, 0xac, 0xa5, 0x3f, 0x66, 0x76, 0x24, 0x3e, 0xfc, 0x3c, 0xac, 0xcf, 0xf9, 0x90, 0x19, 0x84, 0x8c, 0x72, 0x56, 0xa7, 0xbf, 0x63, 0xb6, 0x81, 0xde, 0x82, 0xf5, 0xd9, 0x39, 0x48, 0xbf, 0xb9, 0x59, 0x9b, 0x99, 0x08, 0x16, 0x79, 0x19, 0xbf, 0xa5, 0x41, 0x2d, 0x55, 0x99, 0xc4, 0x42, 0x5a, 0x6e, 0xe4, 0xa2, 0x90, 0x49, 0x5a, 0x56, 0x12, 0xd2, 0x26, 0xeb, 0xce, 0x04, 0x9a, 0xac, 0xc1, 0x37, 0xa1, 0xc6, 0xcf, 0x27, 0xf2, 0xab, 0xdc, 0xd4, 0x57, 0x89, 0xb5, 0x98, 0x10, 0xc5, 0xbf, 0x45, 0x2d, 0x93, 0x88, 0x54, 0x8d, 0x5f, 0xd7, 0x60, 0x29, 0x53, 0x21, 0xb5, 0x20, 0x27, 0xbf, 0x08, 0x8d, 0x14, 0x27, 0xd6, 0x78, 0x47, 0x32, 0xb3, 0x36, 0x87, 0x99, 0x47, 0x3b, 0x66, 0x3d, 0x4a, 0xb5, 0x8c, 0x0f, 0xa0, 0x24, 0xb2, 0xe4, 0x49, 0x25, 0x85, 0xf6, 0x8c, 0xca, 0x9b, 0x33, 0x5e, 0x26, 0x1b, 0xdf, 0xd4, 0xa0, 0xa2, 0x4a, 0x18, 0xd1, 0x35, 0xc8, 0xf9, 0x01, 0xef, 0x7a, 0x2a, 0xce, 0xcd, 0xf9, 0xc1, 0x99, 0xaf, 0xa7, 0x33, 0x2e, 0xb9, 0x70, 0x06, 0x97, 0x6c, 0xfc, 0xaf, 0x06, 0x55, 0x76, 0xa8, 0xe7, 0x81, 0x08, 0xba, 0x0e, 0x05, 0x1e, 0x6e, 0xcf, 0x61, 0x83, 0x23, 0x4e, 0x4b, 0x54, 0x5d, 0x9b, 0x79, 0x93, 0x91, 0x7a, 0x8f, 0x71, 0x1d, 0x6a, 0xd1, 0xb1, 0x1f, 0x52, 0x2b, 0xf5, 0x2a, 0xc3, 0x04, 0x0e, 0xe2, 0x2f, 0x53, 0x98, 0xad, 0x1e, 0xe3, 0xc8, 0xf2, 0xc7, 0x24, 0x74, 0x31, 0x5f, 0x93, 0xaa, 0x42, 0x5c, 0x5e, 0x21, 0xaf, 0x1d, 0xe3, 0xe8, 0x30, 0xc6, 0xaa, 0x3a, 0x33, 0xb4, 0x01, 0x75, 0xf6, 0x5d, 0xdf, 0xb6, 0x7a, 0xfc, 0xa5, 0x8a, 0xb8, 0x42, 0x81, 0x63, 0x1c, 0xdd, 0xb7, 0xef, 0x31, 0x08, 0x63, 0x39, 0xc6, 0x8a, 0xd5, 0x52, 0xee, 0x0b, 0x94, 0xf1, 0x45, 0x21, 0xbb, 0xe0, 0xe0, 0x94, 0xbd, 0x2f, 0x56, 0x76, 0x2e, 0x3d, 0x7d, 0xdf, 0xcb, 0x41, 0x85, 0x7d, 0xce, 0x0f, 0x46, 0x3f, 0x8e, 0xe6, 0x52, 0x81, 0x5a, 0x3e, 0x1b, 0xa8, 0x3d, 0x53, 0x6d, 0xb3, 0xf5, 0x07, 0x67, 0x79, 0x8b, 0x94, 0x3e, 0x75, 0x95, 0xa7, 0x4f, 0x5d, 0x67, 0x3d, 0x1e, 0x4d, 0x1d, 0x7d, 0xaa, 0xb3, 0xaf, 0xe6, 0xae, 0x43, 0x2d, 0x7e, 0x03, 0x40, 0xc5, 0xe1, 0xa8, 0x60, 0x82, 0x02, 0x75, 0xf8, 0x15, 0x65, 0x45, 0x65, 0x94, 0xe2, 0x0d, 0x49, 0x9b, 0x93, 0x72, 0xe2, 0x29, 0x71, 0xb1, 0x21, 0x6d, 0x41, 0x89, 0x6f, 0x60, 0x2a, 0xf7, 0x8d, 0x32, 0x84, 0xdc, 0x8c, 0x4d, 0x49, 0xc1, 0x68, 0xe5, 0x5b, 0x9f, 0xfc, 0x1c, 0x5a, 0xae, 0x41, 0xf5, 0xfe, 0xc7, 0xf8, 0x1c, 0x94, 0x65, 0x71, 0x19, 0x57, 0xea, 0x89, 0x27, 0x8d, 0x80, 0xfd, 0x44, 0x97, 0xa1, 0x14, 0xf1, 0x77, 0x02, 0x72, 0xea, 0x64, 0xcb, 0x78, 0x9b, 0x9f, 0xed, 0x78, 0x16, 0x36, 0x9b, 0xf8, 0xd7, 0x9e, 0x7e, 0xed, 0x95, 0xcb, 0x5c, 0x7b, 0xfd, 0xbd, 0x06, 0x70, 0x40, 0x70, 0x97, 0x84, 0x7c, 0xe8, 0x53, 0x93, 0x68, 0xeb, 0x50, 0x0e, 0x08, 0x09, 0x19, 0x4a, 0xb2, 0xc1, 0x9a, 0xfb, 0xdd, 0x38, 0x07, 0x96, 0x4f, 0xe5, 0xc0, 0xa6, 0x33, 0x6e, 0x85, 0x33, 0x66, 0xdc, 0xde, 0x90, 0xe1, 0x06, 0x93, 0x90, 0xc8, 0xc3, 0x60, 0xa2, 0x37, 0xb6, 0xb7, 0xb4, 0x19, 0x46, 0x84, 0x20, 0xfc, 0xa7, 0xb1, 0x0f, 0xd5, 0x18, 0x3e, 0x9b, 0xee, 0xd1, 0xe6, 0xa7, 0x7b, 0x78, 0xd1, 0x1b, 0x4d, 0x14, 0x8a, 0x7b, 0xa4, 0x13, 0x19, 0x6d, 0x40, 0xe2, 0x9e, 0x8a, 0xab, 0x44, 0xe5, 0x54, 0x5e, 0x4f, 0x32, 0xf1, 0xa2, 0x04, 0x3c, 0x71, 0xf9, 0x89, 0xee, 0xe2, 0x74, 0x3c, 0x6a, 0x40, 0x2e, 0xee, 0x38, 0x47, 0x23, 0xe3, 0x4b, 0xb0, 0x92, 0xe9, 0x54, 0xa6, 0x4f, 0x5b, 0xd9, 0x5e, 0x0b, 0x4f, 0xef, 0x60, 0x0f, 0x50, 0x9b, 0xfa, 0x21, 0x69, 0x33, 0x26, 0xdb, 0x8a, 0xab, 0x6d, 0xa8, 0xb2, 0x18, 0x82, 0x27, 0xdf, 0xe7, 0xed, 0x09, 0x22, 0x39, 0x5f, 0x19, 0xc8, 0x5f, 0xc6, 0x36, 0xac, 0x64, 0x7a, 0x91, 0x6c, 0xa4, 0x74, 0xa1, 0x65, 0x74, 0x61, 0xf3, 0x0b, 0xed, 0xfb, 0x84, 0x19, 0x50, 0xa7, 0x73, 0x70, 0x31, 0xc5, 0x69, 0xbf, 0xaf, 0xf1, 0x4b, 0xe6, 0xd4, 0x28, 0x17, 0x90, 0x5c, 0x4e, 0x1e, 0xbc, 0x70, 0x17, 0x75, 0x6a, 0x79, 0xda, 0xbf, 0x88, 0x3a, 0xae, 0xdd, 0xdb, 0xed, 0x8b, 0xac, 0xe3, 0x7a, 0x8d, 0x85, 0xa7, 0x64, 0xec, 0xf8, 0xa3, 0x28, 0xf5, 0x36, 0x49, 0xf0, 0xa2, 0x2b, 0x4c, 0xfc, 0x32, 0xe9, 0x06, 0x34, 0x62, 0x6a, 0xd1, 0x99, 0xa8, 0xed, 0x5d, 0x52, 0xd0, 0x47, 0xa9, 0xe2, 0xb0, 0xd2, 0x74, 0x71, 0x58, 0x39, 0x96, 0xdc, 0xf8, 0xbe, 0x28, 0x66, 0xe1, 0xc2, 0x9d, 0xb7, 0x9e, 0x5b, 0x50, 0x8e, 0x46, 0xb6, 0x4d, 0xe4, 0xb5, 0x4c, 0xc5, 0x54, 0xcd, 0x0b, 0x11, 0xd6, 0xd8, 0x83, 0xcb, 0xf7, 0x09, 0x7f, 0xb6, 0xca, 0x4e, 0xdc, 0x7c, 0x01, 0x7e, 0xfa, 0xf9, 0x32, 0xbe, 0xa3, 0xc1, 0xfa, 0x4c, 0x37, 0xe7, 0xad, 0x99, 0xcf, 0x32, 0xe7, 0x4b, 0xf9, 0x2e, 0x95, 0x3f, 0x35, 0x5d, 0xa0, 0xc8, 0x8c, 0x7f, 0x14, 0xb5, 0x33, 0xbb, 0xbe, 0x0c, 0x90, 0xfd, 0x70, 0xc1, 0x42, 0x08, 0xdb, 0x0f, 0x42, 0xcb, 0xc3, 0x43, 0x95, 0xc2, 0xab, 0x30, 0xc0, 0x43, 0x3c, 0xe4, 0x1b, 0x2d, 0x47, 0xca, 0xb8, 0xdc, 0x0a, 0xc9, 0x87, 0x72, 0x59, 0x36, 0x18, 0x5c, 0x25, 0x89, 0xc9, 0x87, 0xa9, 0x1b, 0xc0, 0xc2, 0xb3, 0xaa, 0x52, 0x90, 0x3c, 0xad, 0x89, 0x19, 0x13, 0x47, 0xb3, 0x11, 0xaf, 0xbd, 0xc9, 0x88, 0x72, 0xde, 0x0a, 0x46, 0xa9, 0x43, 0xa2, 0x1a, 0xf6, 0x63, 0x51, 0x93, 0xc8, 0x1d, 0x6f, 0x34, 0x1a, 0x2e, 0xa2, 0xbf, 0x2f, 0x40, 0x15, 0xbb, 0x7d, 0x3f, 0x74, 0xe8, 0xf1, 0x90, 0x0f, 0xd8, 0xd8, 0xb9, 0x9a, 0x50, 0xcb, 0x8e, 0x6f, 0x2b, 0x0a, 0x33, 0x21, 0xfe, 0x34, 0x97, 0xa6, 0x7f, 0x2d, 0xea, 0x86, 0x12, 0x3e, 0xcf, 0x5b, 0x39, 0x57, 0xa1, 0x62, 0xcb, 0xce, 0xe3, 0xb0, 0x58, 0xb6, 0x99, 0x85, 0x88, 0x63, 0xef, 0x60, 0x1c, 0xbf, 0x26, 0xe3, 0x80, 0x07, 0x63, 0x1e, 0x3e, 0x09, 0xa4, 0x38, 0xf9, 0x8b, 0x18, 0x0f, 0x38, 0x88, 0x1f, 0xfd, 0xb7, 0x6e, 0x02, 0x24, 0xd7, 0x09, 0xa8, 0x04, 0xb9, 0x47, 0x6f, 0xe8, 0x97, 0x50, 0x15, 0x8a, 0x8f, 0xde, 0xe8, 0x74, 0x0e, 0x74, 0x8d, 0x83, 0x76, 0xf4, 0xdc, 0xd6, 0x67, 0x00, 0x92, 0x6b, 0x2f, 0x04, 0x50, 0x7a, 0xe8, 0x87, 0x43, 0xec, 0xea, 0x97, 0x50, 0x19, 0xf2, 0x07, 0xfe, 0x13, 0x5d, 0x43, 0x15, 0x28, 0xbc, 0xe3, 0xf4, 0x8f, 0xf5, 0xdc, 0xd6, 0x2d, 0x68, 0x64, 0xef, 0xba, 0x58, 0x37, 0xed, 0x7d, 0xfd, 0x12, 0xfb, 0x6b, 0xee, 0xea, 0x1a, 0x5a, 0x82, 0xaa, 0xb9, 0x2b, 0xde, 0x4f, 0xb6, 0xf5, 0xdc, 0xd6, 0x23, 0xa8, 0xa5, 0xee, 0x4d, 0xd0, 0x2a, 0xe8, 0x0f, 0x7d, 0x7a, 0xdb, 0x75, 0xfd, 0x27, 0xa4, 0x7b, 0xe8, 0x31, 0xb0, 0x7e, 0x09, 0xad, 0xc3, 0x4a, 0x0c, 0xba, 0xed, 0x0e, 0xfd, 0x88, 0x72, 0x84, 0x86, 0x5a, 0xb0, 0x9a, 0x42, 0xf0, 0x34, 0x23, 0xc7, 0xe4, 0xb6, 0x6c, 0xc8, 0x1d, 0x06, 0x8c, 0xc3, 0xa3, 0x11, 0x15, 0xac, 0xee, 0x11, 0x57, 0xb0, 0xca, 0xfc, 0x85, 0x9e, 0x43, 0x75, 0xa8, 0xa8, 0x83, 0x80, 0x9e, 0x67, 0x72, 0xed, 0x7b, 0xec, 0x5c, 0xa3, 0x17, 0xd0, 0x0a, 0x34, 0xa7, 0x1e, 0x7d, 0xea, 0x45, 0x84, 0xa0, 0xc1, 0xb9, 0x56, 0xae, 0x2e, 0xd2, 0x4b, 0x5b, 0xdb, 0x50, 0x8d, 0xcf, 0x45, 0xac, 0xe7, 0x87, 0xbe, 0x47, 0x84, 0x12, 0x39, 0x89, 0xae, 0xb1, 0x41, 0xd4, 0x07, 0x42, 0x3b, 0xd9, 0xff, 0xd3, 0xc0, 0xf8, 0x3a, 0xec, 0xf5, 0xf4, 0x4b, 0xec, 0xeb, 0x7b, 0x98, 0x7f, 0x02, 0x50, 0x6a, 0xd3, 0xd0, 0xb1, 0xd9, 0x07, 0x7f, 0xac, 0x41, 0x49, 0x3c, 0xce, 0x14, 0x3d, 0x89, 0xdf, 0xfa, 0x25, 0xb4, 0x06, 0xcb, 0x9d, 0xce, 0x81, 0x48, 0x45, 0xc6, 0x52, 0x70, 0x7d, 0x30, 0x76, 0xd5, 0x90, 0x31, 0x26, 0xc7, 0x3e, 0x78, 0x2f, 0xce, 0x1d, 0xb6, 0x8f, 0x46, 0xd1, 0x31, 0xe9, 0xea, 0x79, 0xb4, 0x01, 0x2f, 0xc4, 0xfd, 0xcc, 0x79, 0xfa, 0xad, 0x17, 0xd0, 0x15, 0x58, 0x4b, 0x77, 0xb9, 0xe7, 0x3f, 0xf4, 0xe9, 0xb1, 0xe3, 0xf5, 0xf5, 0xe2, 0xd6, 0x0d, 0x28, 0xdf, 0x3d, 0xa1, 0x21, 0x3e, 0x0c, 0x84, 0xf0, 0x7e, 0xa0, 0x5f, 0x42, 0x3a, 0xd4, 0x59, 0x3c, 0x77, 0xe8, 0x76, 0xb9, 0xab, 0xd7, 0xb5, 0x2d, 0x03, 0x96, 0x67, 0xd6, 0x1b, 0x33, 0x83, 0xdd, 0xd0, 0x7e, 0xeb, 0x4d, 0xeb, 0x97, 0xfd, 0x50, 0xbf, 0x74, 0xe7, 0x95, 0x7f, 0xfe, 0xf3, 0x8a, 0xf6, 0xfd, 0x4f, 0x5e, 0xd2, 0x7e, 0xf4, 0xc9, 0x4b, 0xda, 0xbf, 0x7f, 0xf2, 0x92, 0xf6, 0xdd, 0xff, 0x7c, 0xe9, 0x12, 0xe8, 0x7e, 0xd8, 0xdf, 0xa6, 0xce, 0x60, 0xbc, 0x3d, 0x18, 0xf3, 0xff, 0x04, 0xf4, 0xb8, 0xc4, 0xff, 0x7c, 0xee, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x4e, 0xad, 0xb5, 0xab, 0x8d, 0x48, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/metapb/000077500000000000000000000000001421456440000163365ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/metapb/metapb.pb.go000066400000000000000000002316331421456440000205450ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: metapb.proto package metapb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" encryptionpb "github.com/pingcap/kvproto/pkg/encryptionpb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type StoreState int32 const ( StoreState_Up StoreState = 0 StoreState_Offline StoreState = 1 StoreState_Tombstone StoreState = 2 ) var StoreState_name = map[int32]string{ 0: "Up", 1: "Offline", 2: "Tombstone", } var StoreState_value = map[string]int32{ "Up": 0, "Offline": 1, "Tombstone": 2, } func (x StoreState) String() string { return proto.EnumName(StoreState_name, int32(x)) } func (StoreState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{0} } // NodeState is going to replace StoreState to make the state concept more clear. // "Up" is devided into "Preparing" and "Serving" stages so that we can better describe the online process. // "Removing" is just like previous `Offline` which is more accurate. // "Removed" has the same meaning with `Tombstone`. type NodeState int32 const ( NodeState_Preparing NodeState = 0 NodeState_Serving NodeState = 1 NodeState_Removing NodeState = 2 NodeState_Removed NodeState = 3 ) var NodeState_name = map[int32]string{ 0: "Preparing", 1: "Serving", 2: "Removing", 3: "Removed", } var NodeState_value = map[string]int32{ "Preparing": 0, "Serving": 1, "Removing": 2, "Removed": 3, } func (x NodeState) String() string { return proto.EnumName(NodeState_name, int32(x)) } func (NodeState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{1} } type PeerRole int32 const ( // Voter -> Voter PeerRole_Voter PeerRole = 0 // Learner/None -> Learner PeerRole_Learner PeerRole = 1 // Learner/None -> Voter PeerRole_IncomingVoter PeerRole = 2 // Voter -> Learner PeerRole_DemotingVoter PeerRole = 3 ) var PeerRole_name = map[int32]string{ 0: "Voter", 1: "Learner", 2: "IncomingVoter", 3: "DemotingVoter", } var PeerRole_value = map[string]int32{ "Voter": 0, "Learner": 1, "IncomingVoter": 2, "DemotingVoter": 3, } func (x PeerRole) String() string { return proto.EnumName(PeerRole_name, int32(x)) } func (PeerRole) EnumDescriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{2} } type Cluster struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // max peer count for a region. // pd will do the auto-balance if region peer count mismatches. MaxPeerCount uint32 `protobuf:"varint,2,opt,name=max_peer_count,json=maxPeerCount,proto3" json:"max_peer_count,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Cluster) Reset() { *m = Cluster{} } func (m *Cluster) String() string { return proto.CompactTextString(m) } func (*Cluster) ProtoMessage() {} func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{0} } func (m *Cluster) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Cluster.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Cluster) XXX_Merge(src proto.Message) { xxx_messageInfo_Cluster.Merge(dst, src) } func (m *Cluster) XXX_Size() int { return m.Size() } func (m *Cluster) XXX_DiscardUnknown() { xxx_messageInfo_Cluster.DiscardUnknown(m) } var xxx_messageInfo_Cluster proto.InternalMessageInfo func (m *Cluster) GetId() uint64 { if m != nil { return m.Id } return 0 } func (m *Cluster) GetMaxPeerCount() uint32 { if m != nil { return m.MaxPeerCount } return 0 } // Case insensitive key/value for replica constraints. type StoreLabel struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreLabel) Reset() { *m = StoreLabel{} } func (m *StoreLabel) String() string { return proto.CompactTextString(m) } func (*StoreLabel) ProtoMessage() {} func (*StoreLabel) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{1} } func (m *StoreLabel) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreLabel.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreLabel) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreLabel.Merge(dst, src) } func (m *StoreLabel) XXX_Size() int { return m.Size() } func (m *StoreLabel) XXX_DiscardUnknown() { xxx_messageInfo_StoreLabel.DiscardUnknown(m) } var xxx_messageInfo_StoreLabel proto.InternalMessageInfo func (m *StoreLabel) GetKey() string { if m != nil { return m.Key } return "" } func (m *StoreLabel) GetValue() string { if m != nil { return m.Value } return "" } type Store struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // Address to handle client requests (kv, cop, etc.) Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` State StoreState `protobuf:"varint,3,opt,name=state,proto3,enum=metapb.StoreState" json:"state,omitempty"` Labels []*StoreLabel `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"` Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` // Address to handle peer requests (raft messages from other store). // Empty means same as address. PeerAddress string `protobuf:"bytes,6,opt,name=peer_address,json=peerAddress,proto3" json:"peer_address,omitempty"` // Status address provides the HTTP service for external components StatusAddress string `protobuf:"bytes,7,opt,name=status_address,json=statusAddress,proto3" json:"status_address,omitempty"` GitHash string `protobuf:"bytes,8,opt,name=git_hash,json=gitHash,proto3" json:"git_hash,omitempty"` // The start timestamp of the current store StartTimestamp int64 `protobuf:"varint,9,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"` DeployPath string `protobuf:"bytes,10,opt,name=deploy_path,json=deployPath,proto3" json:"deploy_path,omitempty"` // The last heartbeat timestamp of the store. LastHeartbeat int64 `protobuf:"varint,11,opt,name=last_heartbeat,json=lastHeartbeat,proto3" json:"last_heartbeat,omitempty"` // If the store is physically destroyed, which means it can never up again. PhysicallyDestroyed bool `protobuf:"varint,12,opt,name=physically_destroyed,json=physicallyDestroyed,proto3" json:"physically_destroyed,omitempty"` // NodeState is used to replace StoreState which will be deprecated in the future. NodeState NodeState `protobuf:"varint,13,opt,name=node_state,json=nodeState,proto3,enum=metapb.NodeState" json:"node_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Store) Reset() { *m = Store{} } func (m *Store) String() string { return proto.CompactTextString(m) } func (*Store) ProtoMessage() {} func (*Store) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{2} } func (m *Store) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Store) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Store.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Store) XXX_Merge(src proto.Message) { xxx_messageInfo_Store.Merge(dst, src) } func (m *Store) XXX_Size() int { return m.Size() } func (m *Store) XXX_DiscardUnknown() { xxx_messageInfo_Store.DiscardUnknown(m) } var xxx_messageInfo_Store proto.InternalMessageInfo func (m *Store) GetId() uint64 { if m != nil { return m.Id } return 0 } func (m *Store) GetAddress() string { if m != nil { return m.Address } return "" } func (m *Store) GetState() StoreState { if m != nil { return m.State } return StoreState_Up } func (m *Store) GetLabels() []*StoreLabel { if m != nil { return m.Labels } return nil } func (m *Store) GetVersion() string { if m != nil { return m.Version } return "" } func (m *Store) GetPeerAddress() string { if m != nil { return m.PeerAddress } return "" } func (m *Store) GetStatusAddress() string { if m != nil { return m.StatusAddress } return "" } func (m *Store) GetGitHash() string { if m != nil { return m.GitHash } return "" } func (m *Store) GetStartTimestamp() int64 { if m != nil { return m.StartTimestamp } return 0 } func (m *Store) GetDeployPath() string { if m != nil { return m.DeployPath } return "" } func (m *Store) GetLastHeartbeat() int64 { if m != nil { return m.LastHeartbeat } return 0 } func (m *Store) GetPhysicallyDestroyed() bool { if m != nil { return m.PhysicallyDestroyed } return false } func (m *Store) GetNodeState() NodeState { if m != nil { return m.NodeState } return NodeState_Preparing } type RegionEpoch struct { // Conf change version, auto increment when add or remove peer ConfVer uint64 `protobuf:"varint,1,opt,name=conf_ver,json=confVer,proto3" json:"conf_ver,omitempty"` // Region version, auto increment when split or merge Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionEpoch) Reset() { *m = RegionEpoch{} } func (m *RegionEpoch) String() string { return proto.CompactTextString(m) } func (*RegionEpoch) ProtoMessage() {} func (*RegionEpoch) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{3} } func (m *RegionEpoch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionEpoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionEpoch.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionEpoch) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionEpoch.Merge(dst, src) } func (m *RegionEpoch) XXX_Size() int { return m.Size() } func (m *RegionEpoch) XXX_DiscardUnknown() { xxx_messageInfo_RegionEpoch.DiscardUnknown(m) } var xxx_messageInfo_RegionEpoch proto.InternalMessageInfo func (m *RegionEpoch) GetConfVer() uint64 { if m != nil { return m.ConfVer } return 0 } func (m *RegionEpoch) GetVersion() uint64 { if m != nil { return m.Version } return 0 } type BucketStats struct { // total read in bytes of each bucket ReadBytes []uint64 `protobuf:"varint,1,rep,packed,name=read_bytes,json=readBytes" json:"read_bytes,omitempty"` // total write in bytes of each bucket WriteBytes []uint64 `protobuf:"varint,2,rep,packed,name=write_bytes,json=writeBytes" json:"write_bytes,omitempty"` // total read qps of each bucket ReadQps []uint64 `protobuf:"varint,3,rep,packed,name=read_qps,json=readQps" json:"read_qps,omitempty"` // total write qps of each bucket WriteQps []uint64 `protobuf:"varint,4,rep,packed,name=write_qps,json=writeQps" json:"write_qps,omitempty"` // total read keys of each bucket ReadKeys []uint64 `protobuf:"varint,5,rep,packed,name=read_keys,json=readKeys" json:"read_keys,omitempty"` // total write keys of each bucket WriteKeys []uint64 `protobuf:"varint,6,rep,packed,name=write_keys,json=writeKeys" json:"write_keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BucketStats) Reset() { *m = BucketStats{} } func (m *BucketStats) String() string { return proto.CompactTextString(m) } func (*BucketStats) ProtoMessage() {} func (*BucketStats) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{4} } func (m *BucketStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BucketStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BucketStats.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BucketStats) XXX_Merge(src proto.Message) { xxx_messageInfo_BucketStats.Merge(dst, src) } func (m *BucketStats) XXX_Size() int { return m.Size() } func (m *BucketStats) XXX_DiscardUnknown() { xxx_messageInfo_BucketStats.DiscardUnknown(m) } var xxx_messageInfo_BucketStats proto.InternalMessageInfo func (m *BucketStats) GetReadBytes() []uint64 { if m != nil { return m.ReadBytes } return nil } func (m *BucketStats) GetWriteBytes() []uint64 { if m != nil { return m.WriteBytes } return nil } func (m *BucketStats) GetReadQps() []uint64 { if m != nil { return m.ReadQps } return nil } func (m *BucketStats) GetWriteQps() []uint64 { if m != nil { return m.WriteQps } return nil } func (m *BucketStats) GetReadKeys() []uint64 { if m != nil { return m.ReadKeys } return nil } func (m *BucketStats) GetWriteKeys() []uint64 { if m != nil { return m.WriteKeys } return nil } type Buckets struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // A hint indicate if keys have changed. Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` // keys of buckets, include start/end key of region Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` // bucket stats Stats *BucketStats `protobuf:"bytes,4,opt,name=stats" json:"stats,omitempty"` // The period in milliseconds that stats are collected with in PeriodInMs uint64 `protobuf:"varint,5,opt,name=period_in_ms,json=periodInMs,proto3" json:"period_in_ms,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Buckets) Reset() { *m = Buckets{} } func (m *Buckets) String() string { return proto.CompactTextString(m) } func (*Buckets) ProtoMessage() {} func (*Buckets) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{5} } func (m *Buckets) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Buckets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Buckets.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Buckets) XXX_Merge(src proto.Message) { xxx_messageInfo_Buckets.Merge(dst, src) } func (m *Buckets) XXX_Size() int { return m.Size() } func (m *Buckets) XXX_DiscardUnknown() { xxx_messageInfo_Buckets.DiscardUnknown(m) } var xxx_messageInfo_Buckets proto.InternalMessageInfo func (m *Buckets) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *Buckets) GetVersion() uint64 { if m != nil { return m.Version } return 0 } func (m *Buckets) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } func (m *Buckets) GetStats() *BucketStats { if m != nil { return m.Stats } return nil } func (m *Buckets) GetPeriodInMs() uint64 { if m != nil { return m.PeriodInMs } return 0 } type Region struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // Region key range [start_key, end_key). StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` RegionEpoch *RegionEpoch `protobuf:"bytes,4,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` Peers []*Peer `protobuf:"bytes,5,rep,name=peers" json:"peers,omitempty"` // Encryption metadata for start_key and end_key. encryption_meta.iv is IV for start_key. // IV for end_key is calculated from (encryption_meta.iv + len(start_key)). // The field is only used by PD and should be ignored otherwise. // If encryption_meta is empty (i.e. nil), it means start_key and end_key are unencrypted. EncryptionMeta *encryptionpb.EncryptionMeta `protobuf:"bytes,6,opt,name=encryption_meta,json=encryptionMeta" json:"encryption_meta,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Region) Reset() { *m = Region{} } func (m *Region) String() string { return proto.CompactTextString(m) } func (*Region) ProtoMessage() {} func (*Region) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{6} } func (m *Region) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Region) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Region.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Region) XXX_Merge(src proto.Message) { xxx_messageInfo_Region.Merge(dst, src) } func (m *Region) XXX_Size() int { return m.Size() } func (m *Region) XXX_DiscardUnknown() { xxx_messageInfo_Region.DiscardUnknown(m) } var xxx_messageInfo_Region proto.InternalMessageInfo func (m *Region) GetId() uint64 { if m != nil { return m.Id } return 0 } func (m *Region) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *Region) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *Region) GetRegionEpoch() *RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *Region) GetPeers() []*Peer { if m != nil { return m.Peers } return nil } func (m *Region) GetEncryptionMeta() *encryptionpb.EncryptionMeta { if m != nil { return m.EncryptionMeta } return nil } type Peer struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` Role PeerRole `protobuf:"varint,3,opt,name=role,proto3,enum=metapb.PeerRole" json:"role,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} func (*Peer) Descriptor() ([]byte, []int) { return fileDescriptor_metapb_4b99a30223bb9a2e, []int{7} } func (m *Peer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Peer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Peer.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Peer) XXX_Merge(src proto.Message) { xxx_messageInfo_Peer.Merge(dst, src) } func (m *Peer) XXX_Size() int { return m.Size() } func (m *Peer) XXX_DiscardUnknown() { xxx_messageInfo_Peer.DiscardUnknown(m) } var xxx_messageInfo_Peer proto.InternalMessageInfo func (m *Peer) GetId() uint64 { if m != nil { return m.Id } return 0 } func (m *Peer) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } func (m *Peer) GetRole() PeerRole { if m != nil { return m.Role } return PeerRole_Voter } func init() { proto.RegisterType((*Cluster)(nil), "metapb.Cluster") proto.RegisterType((*StoreLabel)(nil), "metapb.StoreLabel") proto.RegisterType((*Store)(nil), "metapb.Store") proto.RegisterType((*RegionEpoch)(nil), "metapb.RegionEpoch") proto.RegisterType((*BucketStats)(nil), "metapb.BucketStats") proto.RegisterType((*Buckets)(nil), "metapb.Buckets") proto.RegisterType((*Region)(nil), "metapb.Region") proto.RegisterType((*Peer)(nil), "metapb.Peer") proto.RegisterEnum("metapb.StoreState", StoreState_name, StoreState_value) proto.RegisterEnum("metapb.NodeState", NodeState_name, NodeState_value) proto.RegisterEnum("metapb.PeerRole", PeerRole_name, PeerRole_value) } func (m *Cluster) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Cluster) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Id)) } if m.MaxPeerCount != 0 { dAtA[i] = 0x10 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.MaxPeerCount)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreLabel) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreLabel) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Store) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Store) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Id)) } if len(m.Address) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.Address))) i += copy(dAtA[i:], m.Address) } if m.State != 0 { dAtA[i] = 0x18 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.State)) } if len(m.Labels) > 0 { for _, msg := range m.Labels { dAtA[i] = 0x22 i++ i = encodeVarintMetapb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Version) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.Version))) i += copy(dAtA[i:], m.Version) } if len(m.PeerAddress) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.PeerAddress))) i += copy(dAtA[i:], m.PeerAddress) } if len(m.StatusAddress) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.StatusAddress))) i += copy(dAtA[i:], m.StatusAddress) } if len(m.GitHash) > 0 { dAtA[i] = 0x42 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.GitHash))) i += copy(dAtA[i:], m.GitHash) } if m.StartTimestamp != 0 { dAtA[i] = 0x48 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.StartTimestamp)) } if len(m.DeployPath) > 0 { dAtA[i] = 0x52 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.DeployPath))) i += copy(dAtA[i:], m.DeployPath) } if m.LastHeartbeat != 0 { dAtA[i] = 0x58 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.LastHeartbeat)) } if m.PhysicallyDestroyed { dAtA[i] = 0x60 i++ if m.PhysicallyDestroyed { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.NodeState != 0 { dAtA[i] = 0x68 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.NodeState)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionEpoch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionEpoch) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ConfVer != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.ConfVer)) } if m.Version != 0 { dAtA[i] = 0x10 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Version)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BucketStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BucketStats) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ReadBytes) > 0 { dAtA2 := make([]byte, len(m.ReadBytes)*10) var j1 int for _, num := range m.ReadBytes { for num >= 1<<7 { dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j1++ } dAtA2[j1] = uint8(num) j1++ } dAtA[i] = 0xa i++ i = encodeVarintMetapb(dAtA, i, uint64(j1)) i += copy(dAtA[i:], dAtA2[:j1]) } if len(m.WriteBytes) > 0 { dAtA4 := make([]byte, len(m.WriteBytes)*10) var j3 int for _, num := range m.WriteBytes { for num >= 1<<7 { dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j3++ } dAtA4[j3] = uint8(num) j3++ } dAtA[i] = 0x12 i++ i = encodeVarintMetapb(dAtA, i, uint64(j3)) i += copy(dAtA[i:], dAtA4[:j3]) } if len(m.ReadQps) > 0 { dAtA6 := make([]byte, len(m.ReadQps)*10) var j5 int for _, num := range m.ReadQps { for num >= 1<<7 { dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j5++ } dAtA6[j5] = uint8(num) j5++ } dAtA[i] = 0x1a i++ i = encodeVarintMetapb(dAtA, i, uint64(j5)) i += copy(dAtA[i:], dAtA6[:j5]) } if len(m.WriteQps) > 0 { dAtA8 := make([]byte, len(m.WriteQps)*10) var j7 int for _, num := range m.WriteQps { for num >= 1<<7 { dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j7++ } dAtA8[j7] = uint8(num) j7++ } dAtA[i] = 0x22 i++ i = encodeVarintMetapb(dAtA, i, uint64(j7)) i += copy(dAtA[i:], dAtA8[:j7]) } if len(m.ReadKeys) > 0 { dAtA10 := make([]byte, len(m.ReadKeys)*10) var j9 int for _, num := range m.ReadKeys { for num >= 1<<7 { dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j9++ } dAtA10[j9] = uint8(num) j9++ } dAtA[i] = 0x2a i++ i = encodeVarintMetapb(dAtA, i, uint64(j9)) i += copy(dAtA[i:], dAtA10[:j9]) } if len(m.WriteKeys) > 0 { dAtA12 := make([]byte, len(m.WriteKeys)*10) var j11 int for _, num := range m.WriteKeys { for num >= 1<<7 { dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j11++ } dAtA12[j11] = uint8(num) j11++ } dAtA[i] = 0x32 i++ i = encodeVarintMetapb(dAtA, i, uint64(j11)) i += copy(dAtA[i:], dAtA12[:j11]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Buckets) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Buckets) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.RegionId)) } if m.Version != 0 { dAtA[i] = 0x10 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Version)) } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x1a i++ i = encodeVarintMetapb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.Stats != nil { dAtA[i] = 0x22 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Stats.Size())) n13, err := m.Stats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.PeriodInMs != 0 { dAtA[i] = 0x28 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.PeriodInMs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Region) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Region) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Id)) } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintMetapb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.RegionEpoch != nil { dAtA[i] = 0x22 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.RegionEpoch.Size())) n14, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if len(m.Peers) > 0 { for _, msg := range m.Peers { dAtA[i] = 0x2a i++ i = encodeVarintMetapb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.EncryptionMeta != nil { dAtA[i] = 0x32 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.EncryptionMeta.Size())) n15, err := m.EncryptionMeta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Peer) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Peer) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Id)) } if m.StoreId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.StoreId)) } if m.Role != 0 { dAtA[i] = 0x18 i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Role)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintMetapb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *Cluster) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovMetapb(uint64(m.Id)) } if m.MaxPeerCount != 0 { n += 1 + sovMetapb(uint64(m.MaxPeerCount)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreLabel) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Store) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovMetapb(uint64(m.Id)) } l = len(m.Address) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } if m.State != 0 { n += 1 + sovMetapb(uint64(m.State)) } if len(m.Labels) > 0 { for _, e := range m.Labels { l = e.Size() n += 1 + l + sovMetapb(uint64(l)) } } l = len(m.Version) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } l = len(m.PeerAddress) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } l = len(m.StatusAddress) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } l = len(m.GitHash) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } if m.StartTimestamp != 0 { n += 1 + sovMetapb(uint64(m.StartTimestamp)) } l = len(m.DeployPath) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } if m.LastHeartbeat != 0 { n += 1 + sovMetapb(uint64(m.LastHeartbeat)) } if m.PhysicallyDestroyed { n += 2 } if m.NodeState != 0 { n += 1 + sovMetapb(uint64(m.NodeState)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionEpoch) Size() (n int) { var l int _ = l if m.ConfVer != 0 { n += 1 + sovMetapb(uint64(m.ConfVer)) } if m.Version != 0 { n += 1 + sovMetapb(uint64(m.Version)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BucketStats) Size() (n int) { var l int _ = l if len(m.ReadBytes) > 0 { l = 0 for _, e := range m.ReadBytes { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if len(m.WriteBytes) > 0 { l = 0 for _, e := range m.WriteBytes { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if len(m.ReadQps) > 0 { l = 0 for _, e := range m.ReadQps { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if len(m.WriteQps) > 0 { l = 0 for _, e := range m.WriteQps { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if len(m.ReadKeys) > 0 { l = 0 for _, e := range m.ReadKeys { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if len(m.WriteKeys) > 0 { l = 0 for _, e := range m.WriteKeys { l += sovMetapb(uint64(e)) } n += 1 + sovMetapb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Buckets) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovMetapb(uint64(m.RegionId)) } if m.Version != 0 { n += 1 + sovMetapb(uint64(m.Version)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovMetapb(uint64(l)) } } if m.Stats != nil { l = m.Stats.Size() n += 1 + l + sovMetapb(uint64(l)) } if m.PeriodInMs != 0 { n += 1 + sovMetapb(uint64(m.PeriodInMs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Region) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovMetapb(uint64(m.Id)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovMetapb(uint64(l)) } if len(m.Peers) > 0 { for _, e := range m.Peers { l = e.Size() n += 1 + l + sovMetapb(uint64(l)) } } if m.EncryptionMeta != nil { l = m.EncryptionMeta.Size() n += 1 + l + sovMetapb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Peer) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovMetapb(uint64(m.Id)) } if m.StoreId != 0 { n += 1 + sovMetapb(uint64(m.StoreId)) } if m.Role != 0 { n += 1 + sovMetapb(uint64(m.Role)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovMetapb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozMetapb(x uint64) (n int) { return sovMetapb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *Cluster) 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 ErrIntOverflowMetapb } 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: Cluster: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MaxPeerCount", wireType) } m.MaxPeerCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MaxPeerCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *StoreLabel) 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 ErrIntOverflowMetapb } 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: StoreLabel: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreLabel: 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 ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *Store) 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 ErrIntOverflowMetapb } 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: Store: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Store: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Address = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= (StoreState(b) & 0x7F) << shift if b < 0x80 { break } } 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 ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Labels = append(m.Labels, &StoreLabel{}) if err := m.Labels[len(m.Labels)-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 Version", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PeerAddress", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PeerAddress = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StatusAddress", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.StatusAddress = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GitHash", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.GitHash = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTimestamp", wireType) } m.StartTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTimestamp |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DeployPath", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } 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 ErrInvalidLengthMetapb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.DeployPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LastHeartbeat", wireType) } m.LastHeartbeat = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LastHeartbeat |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PhysicallyDestroyed", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.PhysicallyDestroyed = bool(v != 0) case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NodeState", wireType) } m.NodeState = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NodeState |= (NodeState(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *RegionEpoch) 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 ErrIntOverflowMetapb } 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: RegionEpoch: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionEpoch: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ConfVer", wireType) } m.ConfVer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ConfVer |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *BucketStats) 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 ErrIntOverflowMetapb } 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: BucketStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BucketStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadBytes = append(m.ReadBytes, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadBytes = append(m.ReadBytes, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType) } case 2: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteBytes = append(m.WriteBytes, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteBytes = append(m.WriteBytes, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field WriteBytes", wireType) } case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadQps = append(m.ReadQps, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadQps = append(m.ReadQps, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field ReadQps", wireType) } case 4: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteQps = append(m.WriteQps, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteQps = append(m.WriteQps, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field WriteQps", wireType) } case 5: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadKeys = append(m.ReadKeys, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadKeys = append(m.ReadKeys, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field ReadKeys", wireType) } case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteKeys = append(m.WriteKeys, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.WriteKeys = append(m.WriteKeys, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field WriteKeys", wireType) } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *Buckets) 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 ErrIntOverflowMetapb } 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: Buckets: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Buckets: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Stats == nil { m.Stats = &BucketStats{} } if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PeriodInMs", wireType) } m.PeriodInMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PeriodInMs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *Region) 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 ErrIntOverflowMetapb } 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: Region: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Region: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Peers = append(m.Peers, &Peer{}) if err := m.Peers[len(m.Peers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EncryptionMeta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMetapb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.EncryptionMeta == nil { m.EncryptionMeta = &encryptionpb.EncryptionMeta{} } if err := m.EncryptionMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 *Peer) 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 ErrIntOverflowMetapb } 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: Peer: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Peer: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) } m.Role = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMetapb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Role |= (PeerRole(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipMetapb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMetapb } 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 skipMetapb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetapb } 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, ErrIntOverflowMetapb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetapb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthMetapb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMetapb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipMetapb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthMetapb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowMetapb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("metapb.proto", fileDescriptor_metapb_4b99a30223bb9a2e) } var fileDescriptor_metapb_4b99a30223bb9a2e = []byte{ // 919 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0xcf, 0x72, 0xdc, 0xc4, 0x13, 0x8e, 0xf6, 0xaf, 0xd4, 0xd2, 0xae, 0x37, 0x13, 0x57, 0xfd, 0xe4, 0xe4, 0x87, 0x59, 0xb6, 0xf8, 0xb3, 0xf8, 0x60, 0x82, 0xa1, 0xb8, 0x52, 0x6c, 0xe2, 0x2a, 0xbb, 0x92, 0x80, 0x91, 0x43, 0x38, 0xaa, 0x66, 0x57, 0xed, 0x5d, 0xd5, 0x4a, 0x1a, 0x31, 0x33, 0xbb, 0x44, 0x6f, 0xc2, 0x95, 0x1b, 0xaf, 0xc1, 0x8d, 0x23, 0x47, 0x0e, 0x1c, 0x28, 0xf3, 0x04, 0xbc, 0x01, 0xd5, 0x33, 0xd2, 0xc6, 0x8e, 0x8b, 0x93, 0xa6, 0xbf, 0xaf, 0xbb, 0xa7, 0xe7, 0x9b, 0xe9, 0x16, 0x04, 0x39, 0x6a, 0x5e, 0xce, 0x8f, 0x4b, 0x29, 0xb4, 0x60, 0x3d, 0x6b, 0x3d, 0x64, 0x58, 0x2c, 0x64, 0x55, 0xea, 0x54, 0x14, 0x0d, 0xf7, 0x70, 0x7f, 0x29, 0x96, 0xc2, 0x2c, 0x3f, 0xa1, 0x55, 0x8d, 0xee, 0xc9, 0x8d, 0xd2, 0x66, 0x69, 0x81, 0xc9, 0x97, 0xd0, 0x7f, 0x92, 0x6d, 0x94, 0x46, 0xc9, 0x86, 0xd0, 0x4a, 0x93, 0xd0, 0x19, 0x3b, 0xd3, 0x4e, 0xd4, 0x4a, 0x13, 0xf6, 0x3e, 0x0c, 0x73, 0xfe, 0x3a, 0x2e, 0x11, 0x65, 0xbc, 0x10, 0x9b, 0x42, 0x87, 0xad, 0xb1, 0x33, 0x1d, 0x44, 0x41, 0xce, 0x5f, 0x5f, 0x20, 0xca, 0x27, 0x84, 0x4d, 0x3e, 0x07, 0xb8, 0xd4, 0x42, 0xe2, 0x73, 0x3e, 0xc7, 0x8c, 0x8d, 0xa0, 0xbd, 0xc6, 0xca, 0x24, 0xf1, 0x22, 0x5a, 0xb2, 0x7d, 0xe8, 0x6e, 0x79, 0xb6, 0x41, 0x13, 0xec, 0x45, 0xd6, 0x98, 0xfc, 0xd9, 0x86, 0xae, 0x09, 0xbb, 0xb3, 0x6b, 0x08, 0x7d, 0x9e, 0x24, 0x12, 0x95, 0xaa, 0x23, 0x1a, 0x93, 0x4d, 0xa1, 0xab, 0x34, 0xd7, 0x18, 0xb6, 0xc7, 0xce, 0x74, 0x78, 0xc2, 0x8e, 0x6b, 0x2d, 0x4c, 0x9e, 0x4b, 0x62, 0x22, 0xeb, 0xc0, 0x8e, 0xa0, 0x97, 0x51, 0x39, 0x2a, 0xec, 0x8c, 0xdb, 0x53, 0xff, 0x2d, 0x57, 0x53, 0x69, 0x54, 0x7b, 0xd0, 0x7e, 0x5b, 0x94, 0x2a, 0x15, 0x45, 0xd8, 0xb5, 0xfb, 0xd5, 0x26, 0x7b, 0x0f, 0x02, 0x73, 0xf6, 0xa6, 0x9c, 0x9e, 0xa1, 0x7d, 0xc2, 0xbe, 0xaa, 0x4b, 0xfa, 0x00, 0x86, 0xb4, 0xe3, 0x46, 0xed, 0x9c, 0xfa, 0xc6, 0x69, 0x60, 0xd1, 0xc6, 0xed, 0x00, 0xdc, 0x65, 0xaa, 0xe3, 0x15, 0x57, 0xab, 0xd0, 0xb5, 0x9b, 0x2c, 0x53, 0x7d, 0xc6, 0xd5, 0x8a, 0x7d, 0x04, 0x7b, 0x4a, 0x73, 0xa9, 0x63, 0x9d, 0xe6, 0xa8, 0x34, 0xcf, 0xcb, 0xd0, 0x1b, 0x3b, 0xd3, 0x76, 0x34, 0x34, 0xf0, 0xcb, 0x06, 0x65, 0xef, 0x82, 0x9f, 0x60, 0x99, 0x89, 0x2a, 0x2e, 0xb9, 0x5e, 0x85, 0x60, 0xd2, 0x80, 0x85, 0x2e, 0xb8, 0x5e, 0x51, 0x2d, 0x19, 0x57, 0x3a, 0x5e, 0x21, 0x97, 0x7a, 0x8e, 0x5c, 0x87, 0xbe, 0x49, 0x34, 0x20, 0xf4, 0xac, 0x01, 0xd9, 0xa7, 0xb0, 0x5f, 0xae, 0x2a, 0x95, 0x2e, 0x78, 0x96, 0x55, 0x71, 0x82, 0x4a, 0x4b, 0x51, 0x61, 0x12, 0x06, 0x63, 0x67, 0xea, 0x46, 0x0f, 0xde, 0x70, 0x4f, 0x1b, 0x8a, 0x3d, 0x06, 0x28, 0x44, 0x82, 0xb1, 0x55, 0x7f, 0x60, 0xd4, 0xbf, 0xdf, 0x48, 0xfa, 0xb5, 0x48, 0x6a, 0xf1, 0xbd, 0xa2, 0x59, 0x4e, 0x66, 0xe0, 0x47, 0xb8, 0x4c, 0x45, 0x71, 0x5a, 0x8a, 0xc5, 0x8a, 0xce, 0xbf, 0x10, 0xc5, 0x55, 0xbc, 0x45, 0x59, 0xdf, 0x74, 0x9f, 0xec, 0x57, 0x28, 0x6f, 0xca, 0xdf, 0xb2, 0x4c, 0x6d, 0x4e, 0x7e, 0x75, 0xc0, 0x9f, 0x6d, 0x16, 0x6b, 0xd4, 0x94, 0x53, 0xb1, 0x77, 0x00, 0x24, 0xf2, 0x24, 0x9e, 0x57, 0x1a, 0x55, 0xe8, 0x8c, 0xdb, 0xd3, 0x4e, 0xe4, 0x11, 0x32, 0x23, 0x80, 0xf4, 0xf9, 0x51, 0xa6, 0x1a, 0x6b, 0xbe, 0x65, 0x78, 0x30, 0x90, 0x75, 0x38, 0x00, 0xd7, 0xc4, 0xff, 0x50, 0xaa, 0xb0, 0x6d, 0xd8, 0x3e, 0xd9, 0xdf, 0x96, 0x8a, 0x3d, 0x02, 0xcf, 0xc6, 0x12, 0xd7, 0x31, 0x9c, 0x6b, 0x80, 0x9a, 0x34, 0x71, 0x6b, 0xac, 0x54, 0xd8, 0xb5, 0x24, 0x01, 0xcf, 0xb0, 0x32, 0x45, 0xd9, 0x48, 0xc3, 0xf6, 0x6c, 0x51, 0x06, 0x21, 0x7a, 0xf2, 0xb3, 0x03, 0x7d, 0x7b, 0x86, 0x3a, 0x0f, 0x69, 0x12, 0xef, 0xde, 0xbb, 0x6b, 0x81, 0xf3, 0xe4, 0xbf, 0x65, 0x60, 0x0c, 0x3a, 0x26, 0x37, 0x95, 0x1c, 0x44, 0x66, 0xcd, 0x3e, 0xb6, 0x9d, 0x40, 0xb5, 0x3a, 0x53, 0xff, 0xe4, 0x41, 0x73, 0x17, 0x37, 0xe4, 0xb2, 0xad, 0xa0, 0xd8, 0x98, 0x1e, 0xb1, 0x4c, 0x45, 0x12, 0xa7, 0x45, 0x9c, 0x2b, 0xf3, 0xc6, 0x3b, 0x11, 0x58, 0xec, 0xbc, 0x78, 0xa1, 0x26, 0xff, 0x38, 0xd0, 0xb3, 0x97, 0x75, 0xa7, 0x17, 0x1f, 0x81, 0x67, 0x1f, 0x27, 0xf5, 0x34, 0xd5, 0x15, 0x44, 0xae, 0x01, 0x9e, 0x61, 0xc5, 0xfe, 0x07, 0x7d, 0x2c, 0x8c, 0x2c, 0xa6, 0x21, 0x83, 0xa8, 0x87, 0x05, 0x89, 0xc2, 0xbe, 0x80, 0xa0, 0x3e, 0x28, 0xd2, 0xed, 0xbf, 0x5d, 0xe4, 0x8d, 0x87, 0x11, 0xf9, 0xf2, 0xc6, 0x2b, 0x99, 0x40, 0x97, 0x7a, 0xcb, 0x8a, 0xec, 0x9f, 0x04, 0x4d, 0x00, 0xcd, 0x9a, 0xc8, 0x52, 0xec, 0x14, 0xf6, 0xde, 0xcc, 0xba, 0x98, 0x1c, 0x4c, 0x5b, 0xfa, 0x27, 0xff, 0x3f, 0xbe, 0x35, 0x03, 0x4f, 0x77, 0xc6, 0x0b, 0xd4, 0x3c, 0x1a, 0xe2, 0x2d, 0x7b, 0xf2, 0x3d, 0x74, 0x28, 0xeb, 0x9d, 0x03, 0x1f, 0x80, 0xab, 0x68, 0x44, 0xd0, 0x15, 0xd5, 0xf7, 0x60, 0xec, 0x73, 0x9a, 0x86, 0x1d, 0x29, 0xb2, 0x66, 0xf8, 0x8c, 0x6e, 0x15, 0x27, 0x32, 0x8c, 0x0c, 0x7b, 0xf4, 0xb8, 0x9e, 0x86, 0xa6, 0x0d, 0x58, 0x0f, 0x5a, 0xdf, 0x95, 0xa3, 0x7b, 0xcc, 0x87, 0xfe, 0x37, 0x57, 0x57, 0x59, 0x5a, 0xe0, 0xc8, 0x61, 0x03, 0xf0, 0x5e, 0x8a, 0x7c, 0xae, 0xb4, 0x28, 0x70, 0xd4, 0x3a, 0x9a, 0x81, 0xb7, 0x6b, 0x21, 0xe2, 0x2e, 0x24, 0x96, 0x5c, 0xa6, 0xc5, 0xd2, 0xc6, 0x5d, 0xa2, 0xdc, 0x92, 0xe1, 0xb0, 0x00, 0xdc, 0x08, 0x73, 0x61, 0xac, 0x16, 0x51, 0xc6, 0xc2, 0x64, 0xd4, 0x3e, 0x3a, 0x03, 0xb7, 0xa9, 0x83, 0x79, 0xd0, 0x7d, 0x25, 0x34, 0x4a, 0x1b, 0xfe, 0x1c, 0xb9, 0x2c, 0x50, 0x8e, 0x1c, 0x76, 0x1f, 0x06, 0xe7, 0xc5, 0x42, 0xe4, 0x69, 0xb1, 0xb4, 0x7c, 0x8b, 0xa0, 0xa7, 0x98, 0x0b, 0xbd, 0x83, 0xda, 0xb3, 0x0f, 0xff, 0xf8, 0xc5, 0x75, 0x7e, 0xbb, 0x3e, 0x74, 0x7e, 0xbf, 0x3e, 0x74, 0xfe, 0xba, 0x3e, 0x74, 0x7e, 0xfa, 0xfb, 0xf0, 0x1e, 0x8c, 0x84, 0x5c, 0x1e, 0xeb, 0x74, 0xbd, 0x3d, 0x5e, 0x6f, 0xcd, 0x6f, 0x63, 0xde, 0x33, 0x9f, 0xcf, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x5c, 0xaf, 0xc4, 0x84, 0x90, 0x06, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/mpp/000077500000000000000000000000001421456440000156625ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/mpp/mpp.pb.go000066400000000000000000001675471421456440000174310ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: mpp.proto package mpp import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" coprocessor "github.com/pingcap/kvproto/pkg/coprocessor" metapb "github.com/pingcap/kvproto/pkg/metapb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package // TaskMeta contains meta of a mpp plan, including query's ts and task address. type TaskMeta struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` TaskId int64 `protobuf:"varint,2,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` PartitionId int64 `protobuf:"varint,3,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"` Address string `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TaskMeta) Reset() { *m = TaskMeta{} } func (m *TaskMeta) String() string { return proto.CompactTextString(m) } func (*TaskMeta) ProtoMessage() {} func (*TaskMeta) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{0} } func (m *TaskMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TaskMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TaskMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TaskMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_TaskMeta.Merge(dst, src) } func (m *TaskMeta) XXX_Size() int { return m.Size() } func (m *TaskMeta) XXX_DiscardUnknown() { xxx_messageInfo_TaskMeta.DiscardUnknown(m) } var xxx_messageInfo_TaskMeta proto.InternalMessageInfo func (m *TaskMeta) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *TaskMeta) GetTaskId() int64 { if m != nil { return m.TaskId } return 0 } func (m *TaskMeta) GetPartitionId() int64 { if m != nil { return m.PartitionId } return 0 } func (m *TaskMeta) GetAddress() string { if m != nil { return m.Address } return "" } type IsAliveRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IsAliveRequest) Reset() { *m = IsAliveRequest{} } func (m *IsAliveRequest) String() string { return proto.CompactTextString(m) } func (*IsAliveRequest) ProtoMessage() {} func (*IsAliveRequest) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{1} } func (m *IsAliveRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IsAliveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IsAliveRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IsAliveRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_IsAliveRequest.Merge(dst, src) } func (m *IsAliveRequest) XXX_Size() int { return m.Size() } func (m *IsAliveRequest) XXX_DiscardUnknown() { xxx_messageInfo_IsAliveRequest.DiscardUnknown(m) } var xxx_messageInfo_IsAliveRequest proto.InternalMessageInfo type IsAliveResponse struct { Available bool `protobuf:"varint,1,opt,name=available,proto3" json:"available,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IsAliveResponse) Reset() { *m = IsAliveResponse{} } func (m *IsAliveResponse) String() string { return proto.CompactTextString(m) } func (*IsAliveResponse) ProtoMessage() {} func (*IsAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{2} } func (m *IsAliveResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IsAliveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IsAliveResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IsAliveResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_IsAliveResponse.Merge(dst, src) } func (m *IsAliveResponse) XXX_Size() int { return m.Size() } func (m *IsAliveResponse) XXX_DiscardUnknown() { xxx_messageInfo_IsAliveResponse.DiscardUnknown(m) } var xxx_messageInfo_IsAliveResponse proto.InternalMessageInfo func (m *IsAliveResponse) GetAvailable() bool { if m != nil { return m.Available } return false } // Dipsatch the task request to different tiflash servers. type DispatchTaskRequest struct { Meta *TaskMeta `protobuf:"bytes,1,opt,name=meta" json:"meta,omitempty"` EncodedPlan []byte `protobuf:"bytes,2,opt,name=encoded_plan,json=encodedPlan,proto3" json:"encoded_plan,omitempty"` Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"` Regions []*coprocessor.RegionInfo `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"` // If this task contains table scan, we still need their region info. SchemaVer int64 `protobuf:"varint,5,opt,name=schema_ver,json=schemaVer,proto3" json:"schema_ver,omitempty"` // Used for partition table scan TableRegions []*coprocessor.TableRegions `protobuf:"bytes,6,rep,name=table_regions,json=tableRegions" json:"table_regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DispatchTaskRequest) Reset() { *m = DispatchTaskRequest{} } func (m *DispatchTaskRequest) String() string { return proto.CompactTextString(m) } func (*DispatchTaskRequest) ProtoMessage() {} func (*DispatchTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{3} } func (m *DispatchTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DispatchTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DispatchTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DispatchTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DispatchTaskRequest.Merge(dst, src) } func (m *DispatchTaskRequest) XXX_Size() int { return m.Size() } func (m *DispatchTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_DispatchTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_DispatchTaskRequest proto.InternalMessageInfo func (m *DispatchTaskRequest) GetMeta() *TaskMeta { if m != nil { return m.Meta } return nil } func (m *DispatchTaskRequest) GetEncodedPlan() []byte { if m != nil { return m.EncodedPlan } return nil } func (m *DispatchTaskRequest) GetTimeout() int64 { if m != nil { return m.Timeout } return 0 } func (m *DispatchTaskRequest) GetRegions() []*coprocessor.RegionInfo { if m != nil { return m.Regions } return nil } func (m *DispatchTaskRequest) GetSchemaVer() int64 { if m != nil { return m.SchemaVer } return 0 } func (m *DispatchTaskRequest) GetTableRegions() []*coprocessor.TableRegions { if m != nil { return m.TableRegions } return nil } // Get response of DispatchTaskRequest. type DispatchTaskResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` RetryRegions []*metapb.Region `protobuf:"bytes,2,rep,name=retry_regions,json=retryRegions" json:"retry_regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DispatchTaskResponse) Reset() { *m = DispatchTaskResponse{} } func (m *DispatchTaskResponse) String() string { return proto.CompactTextString(m) } func (*DispatchTaskResponse) ProtoMessage() {} func (*DispatchTaskResponse) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{4} } func (m *DispatchTaskResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DispatchTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DispatchTaskResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DispatchTaskResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DispatchTaskResponse.Merge(dst, src) } func (m *DispatchTaskResponse) XXX_Size() int { return m.Size() } func (m *DispatchTaskResponse) XXX_DiscardUnknown() { xxx_messageInfo_DispatchTaskResponse.DiscardUnknown(m) } var xxx_messageInfo_DispatchTaskResponse proto.InternalMessageInfo func (m *DispatchTaskResponse) GetError() *Error { if m != nil { return m.Error } return nil } func (m *DispatchTaskResponse) GetRetryRegions() []*metapb.Region { if m != nil { return m.RetryRegions } return nil } // CancelTaskRequest closes the execution of a task. type CancelTaskRequest struct { Meta *TaskMeta `protobuf:"bytes,1,opt,name=meta" json:"meta,omitempty"` Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CancelTaskRequest) Reset() { *m = CancelTaskRequest{} } func (m *CancelTaskRequest) String() string { return proto.CompactTextString(m) } func (*CancelTaskRequest) ProtoMessage() {} func (*CancelTaskRequest) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{5} } func (m *CancelTaskRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CancelTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CancelTaskRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CancelTaskRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CancelTaskRequest.Merge(dst, src) } func (m *CancelTaskRequest) XXX_Size() int { return m.Size() } func (m *CancelTaskRequest) XXX_DiscardUnknown() { xxx_messageInfo_CancelTaskRequest.DiscardUnknown(m) } var xxx_messageInfo_CancelTaskRequest proto.InternalMessageInfo func (m *CancelTaskRequest) GetMeta() *TaskMeta { if m != nil { return m.Meta } return nil } func (m *CancelTaskRequest) GetError() *Error { if m != nil { return m.Error } return nil } type CancelTaskResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CancelTaskResponse) Reset() { *m = CancelTaskResponse{} } func (m *CancelTaskResponse) String() string { return proto.CompactTextString(m) } func (*CancelTaskResponse) ProtoMessage() {} func (*CancelTaskResponse) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{6} } func (m *CancelTaskResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CancelTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CancelTaskResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CancelTaskResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CancelTaskResponse.Merge(dst, src) } func (m *CancelTaskResponse) XXX_Size() int { return m.Size() } func (m *CancelTaskResponse) XXX_DiscardUnknown() { xxx_messageInfo_CancelTaskResponse.DiscardUnknown(m) } var xxx_messageInfo_CancelTaskResponse proto.InternalMessageInfo func (m *CancelTaskResponse) GetError() *Error { if m != nil { return m.Error } return nil } // build connection between different tasks. Data is sent by the tasks that are closer to the data sources. type EstablishMPPConnectionRequest struct { SenderMeta *TaskMeta `protobuf:"bytes,1,opt,name=sender_meta,json=senderMeta" json:"sender_meta,omitempty"` ReceiverMeta *TaskMeta `protobuf:"bytes,2,opt,name=receiver_meta,json=receiverMeta" json:"receiver_meta,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *EstablishMPPConnectionRequest) Reset() { *m = EstablishMPPConnectionRequest{} } func (m *EstablishMPPConnectionRequest) String() string { return proto.CompactTextString(m) } func (*EstablishMPPConnectionRequest) ProtoMessage() {} func (*EstablishMPPConnectionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{7} } func (m *EstablishMPPConnectionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *EstablishMPPConnectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EstablishMPPConnectionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *EstablishMPPConnectionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_EstablishMPPConnectionRequest.Merge(dst, src) } func (m *EstablishMPPConnectionRequest) XXX_Size() int { return m.Size() } func (m *EstablishMPPConnectionRequest) XXX_DiscardUnknown() { xxx_messageInfo_EstablishMPPConnectionRequest.DiscardUnknown(m) } var xxx_messageInfo_EstablishMPPConnectionRequest proto.InternalMessageInfo func (m *EstablishMPPConnectionRequest) GetSenderMeta() *TaskMeta { if m != nil { return m.SenderMeta } return nil } func (m *EstablishMPPConnectionRequest) GetReceiverMeta() *TaskMeta { if m != nil { return m.ReceiverMeta } return nil } // when TiFlash sends data to TiDB, Data packets wrap tipb.SelectResponse, i.e., serialize tipb.SelectResponse into data; // when TiFlash sends data to TiFlash, data blocks are serialized into chunks, and the execution_summaries in tipb.SelectResponse are serialized into data only for the last packet. type MPPDataPacket struct { Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` Chunks [][]byte `protobuf:"bytes,3,rep,name=chunks" json:"chunks,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MPPDataPacket) Reset() { *m = MPPDataPacket{} } func (m *MPPDataPacket) String() string { return proto.CompactTextString(m) } func (*MPPDataPacket) ProtoMessage() {} func (*MPPDataPacket) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{8} } func (m *MPPDataPacket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MPPDataPacket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MPPDataPacket.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MPPDataPacket) XXX_Merge(src proto.Message) { xxx_messageInfo_MPPDataPacket.Merge(dst, src) } func (m *MPPDataPacket) XXX_Size() int { return m.Size() } func (m *MPPDataPacket) XXX_DiscardUnknown() { xxx_messageInfo_MPPDataPacket.DiscardUnknown(m) } var xxx_messageInfo_MPPDataPacket proto.InternalMessageInfo func (m *MPPDataPacket) GetData() []byte { if m != nil { return m.Data } return nil } func (m *MPPDataPacket) GetError() *Error { if m != nil { return m.Error } return nil } func (m *MPPDataPacket) GetChunks() [][]byte { if m != nil { return m.Chunks } return nil } type Error struct { Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_mpp_cf0e0fae1ea4debe, []int{9} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetCode() int32 { if m != nil { return m.Code } return 0 } func (m *Error) GetMsg() string { if m != nil { return m.Msg } return "" } func init() { proto.RegisterType((*TaskMeta)(nil), "mpp.TaskMeta") proto.RegisterType((*IsAliveRequest)(nil), "mpp.IsAliveRequest") proto.RegisterType((*IsAliveResponse)(nil), "mpp.IsAliveResponse") proto.RegisterType((*DispatchTaskRequest)(nil), "mpp.DispatchTaskRequest") proto.RegisterType((*DispatchTaskResponse)(nil), "mpp.DispatchTaskResponse") proto.RegisterType((*CancelTaskRequest)(nil), "mpp.CancelTaskRequest") proto.RegisterType((*CancelTaskResponse)(nil), "mpp.CancelTaskResponse") proto.RegisterType((*EstablishMPPConnectionRequest)(nil), "mpp.EstablishMPPConnectionRequest") proto.RegisterType((*MPPDataPacket)(nil), "mpp.MPPDataPacket") proto.RegisterType((*Error)(nil), "mpp.Error") } func (m *TaskMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TaskMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMpp(dAtA, i, uint64(m.StartTs)) } if m.TaskId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintMpp(dAtA, i, uint64(m.TaskId)) } if m.PartitionId != 0 { dAtA[i] = 0x18 i++ i = encodeVarintMpp(dAtA, i, uint64(m.PartitionId)) } if len(m.Address) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintMpp(dAtA, i, uint64(len(m.Address))) i += copy(dAtA[i:], m.Address) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IsAliveRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IsAliveRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IsAliveResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IsAliveResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Available { dAtA[i] = 0x8 i++ if m.Available { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DispatchTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DispatchTaskRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Meta != nil { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(m.Meta.Size())) n1, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if len(m.EncodedPlan) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(len(m.EncodedPlan))) i += copy(dAtA[i:], m.EncodedPlan) } if m.Timeout != 0 { dAtA[i] = 0x18 i++ i = encodeVarintMpp(dAtA, i, uint64(m.Timeout)) } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x22 i++ i = encodeVarintMpp(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.SchemaVer != 0 { dAtA[i] = 0x28 i++ i = encodeVarintMpp(dAtA, i, uint64(m.SchemaVer)) } if len(m.TableRegions) > 0 { for _, msg := range m.TableRegions { dAtA[i] = 0x32 i++ i = encodeVarintMpp(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DispatchTaskResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DispatchTaskResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(m.Error.Size())) n2, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if len(m.RetryRegions) > 0 { for _, msg := range m.RetryRegions { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CancelTaskRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CancelTaskRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Meta != nil { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(m.Meta.Size())) n3, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(m.Error.Size())) n4, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CancelTaskResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CancelTaskResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(m.Error.Size())) n5, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *EstablishMPPConnectionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EstablishMPPConnectionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.SenderMeta != nil { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(m.SenderMeta.Size())) n6, err := m.SenderMeta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.ReceiverMeta != nil { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(m.ReceiverMeta.Size())) n7, err := m.ReceiverMeta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MPPDataPacket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MPPDataPacket) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Data) > 0 { dAtA[i] = 0xa i++ i = encodeVarintMpp(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(m.Error.Size())) n8, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if len(m.Chunks) > 0 { for _, b := range m.Chunks { dAtA[i] = 0x1a i++ i = encodeVarintMpp(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Code != 0 { dAtA[i] = 0x8 i++ i = encodeVarintMpp(dAtA, i, uint64(m.Code)) } if len(m.Msg) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintMpp(dAtA, i, uint64(len(m.Msg))) i += copy(dAtA[i:], m.Msg) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintMpp(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *TaskMeta) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovMpp(uint64(m.StartTs)) } if m.TaskId != 0 { n += 1 + sovMpp(uint64(m.TaskId)) } if m.PartitionId != 0 { n += 1 + sovMpp(uint64(m.PartitionId)) } l = len(m.Address) if l > 0 { n += 1 + l + sovMpp(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IsAliveRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IsAliveResponse) Size() (n int) { var l int _ = l if m.Available { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DispatchTaskRequest) Size() (n int) { var l int _ = l if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovMpp(uint64(l)) } l = len(m.EncodedPlan) if l > 0 { n += 1 + l + sovMpp(uint64(l)) } if m.Timeout != 0 { n += 1 + sovMpp(uint64(m.Timeout)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovMpp(uint64(l)) } } if m.SchemaVer != 0 { n += 1 + sovMpp(uint64(m.SchemaVer)) } if len(m.TableRegions) > 0 { for _, e := range m.TableRegions { l = e.Size() n += 1 + l + sovMpp(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DispatchTaskResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovMpp(uint64(l)) } if len(m.RetryRegions) > 0 { for _, e := range m.RetryRegions { l = e.Size() n += 1 + l + sovMpp(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CancelTaskRequest) Size() (n int) { var l int _ = l if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovMpp(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovMpp(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CancelTaskResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovMpp(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *EstablishMPPConnectionRequest) Size() (n int) { var l int _ = l if m.SenderMeta != nil { l = m.SenderMeta.Size() n += 1 + l + sovMpp(uint64(l)) } if m.ReceiverMeta != nil { l = m.ReceiverMeta.Size() n += 1 + l + sovMpp(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MPPDataPacket) Size() (n int) { var l int _ = l l = len(m.Data) if l > 0 { n += 1 + l + sovMpp(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovMpp(uint64(l)) } if len(m.Chunks) > 0 { for _, b := range m.Chunks { l = len(b) n += 1 + l + sovMpp(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l if m.Code != 0 { n += 1 + sovMpp(uint64(m.Code)) } l = len(m.Msg) if l > 0 { n += 1 + l + sovMpp(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovMpp(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozMpp(x uint64) (n int) { return sovMpp(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *TaskMeta) 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 ErrIntOverflowMpp } 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: TaskMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TaskMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType) } m.TaskId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TaskId |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PartitionId", wireType) } m.PartitionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PartitionId |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } 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 ErrInvalidLengthMpp } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Address = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *IsAliveRequest) 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 ErrIntOverflowMpp } 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: IsAliveRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IsAliveRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *IsAliveResponse) 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 ErrIntOverflowMpp } 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: IsAliveResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IsAliveResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Available = bool(v != 0) default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *DispatchTaskRequest) 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 ErrIntOverflowMpp } 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: DispatchTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DispatchTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Meta == nil { m.Meta = &TaskMeta{} } if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EncodedPlan", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EncodedPlan = append(m.EncodedPlan[:0], dAtA[iNdEx:postIndex]...) if m.EncodedPlan == nil { m.EncodedPlan = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) } m.Timeout = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Timeout |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &coprocessor.RegionInfo{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SchemaVer", wireType) } m.SchemaVer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SchemaVer |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TableRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.TableRegions = append(m.TableRegions, &coprocessor.TableRegions{}) if err := m.TableRegions[len(m.TableRegions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *DispatchTaskResponse) 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 ErrIntOverflowMpp } 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: DispatchTaskResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DispatchTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RetryRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RetryRegions = append(m.RetryRegions, &metapb.Region{}) if err := m.RetryRegions[len(m.RetryRegions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *CancelTaskRequest) 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 ErrIntOverflowMpp } 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: CancelTaskRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CancelTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Meta == nil { m.Meta = &TaskMeta{} } if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *CancelTaskResponse) 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 ErrIntOverflowMpp } 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: CancelTaskResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CancelTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *EstablishMPPConnectionRequest) 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 ErrIntOverflowMpp } 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: EstablishMPPConnectionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EstablishMPPConnectionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SenderMeta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.SenderMeta == nil { m.SenderMeta = &TaskMeta{} } if err := m.SenderMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReceiverMeta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReceiverMeta == nil { m.ReceiverMeta = &TaskMeta{} } if err := m.ReceiverMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *MPPDataPacket) 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 ErrIntOverflowMpp } 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: MPPDataPacket: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MPPDataPacket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + byteLen 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 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthMpp } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Chunks = append(m.Chunks, make([]byte, postIndex-iNdEx)) copy(m.Chunks[len(m.Chunks)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 *Error) 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 ErrIntOverflowMpp } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) } m.Code = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Code |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMpp } 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 ErrInvalidLengthMpp } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Msg = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMpp(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthMpp } 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 skipMpp(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMpp } 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, ErrIntOverflowMpp } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMpp } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthMpp } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowMpp } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipMpp(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthMpp = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowMpp = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("mpp.proto", fileDescriptor_mpp_cf0e0fae1ea4debe) } var fileDescriptor_mpp_cf0e0fae1ea4debe = []byte{ // 584 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, 0x14, 0xfd, 0x1c, 0xe7, 0xa7, 0xb9, 0x71, 0xfa, 0xb5, 0x43, 0x45, 0xd3, 0x8a, 0x46, 0xa9, 0x57, 0xd9, 0xe0, 0x8a, 0x56, 0x62, 0x89, 0x04, 0x6d, 0x17, 0x59, 0x54, 0xb2, 0x46, 0x15, 0x62, 0x83, 0xac, 0xa9, 0x7d, 0x49, 0x2c, 0xdb, 0x33, 0x66, 0x66, 0x6a, 0x09, 0xb1, 0x64, 0xc1, 0x2b, 0xf0, 0x48, 0x2c, 0x79, 0x04, 0x54, 0x5e, 0x04, 0xcd, 0xd8, 0x0e, 0xa9, 0x44, 0x05, 0xac, 0x32, 0xe7, 0xdc, 0x3b, 0xe7, 0xde, 0x73, 0x34, 0x31, 0x0c, 0x8b, 0xb2, 0x0c, 0x4a, 0x29, 0xb4, 0x20, 0x6e, 0x51, 0x96, 0x87, 0x7b, 0x4b, 0xb1, 0x14, 0x16, 0x9f, 0x98, 0x53, 0x5d, 0x3a, 0xdc, 0x8d, 0x0d, 0x17, 0xa3, 0x52, 0x42, 0x36, 0x94, 0x57, 0xa0, 0x66, 0xe5, 0x4d, 0x8d, 0xfc, 0x8f, 0xb0, 0x75, 0xcd, 0x54, 0x76, 0x85, 0x9a, 0x91, 0x03, 0xd8, 0x52, 0x9a, 0x49, 0x1d, 0x69, 0x35, 0x71, 0x66, 0xce, 0xbc, 0x4b, 0x07, 0x16, 0x5f, 0x2b, 0xb2, 0x0f, 0x03, 0xcd, 0x54, 0x16, 0xa5, 0xc9, 0xa4, 0x33, 0x73, 0xe6, 0x2e, 0xed, 0x1b, 0xb8, 0x48, 0xc8, 0x31, 0x78, 0x25, 0x93, 0x3a, 0xd5, 0xa9, 0xe0, 0xa6, 0xea, 0xda, 0xea, 0x68, 0xcd, 0x2d, 0x12, 0x32, 0x81, 0x01, 0x4b, 0x12, 0x89, 0x4a, 0x4d, 0xba, 0x33, 0x67, 0x3e, 0xa4, 0x2d, 0xf4, 0x77, 0x60, 0x7b, 0xa1, 0x5e, 0xe6, 0x69, 0x85, 0x14, 0xdf, 0xdf, 0xa2, 0xd2, 0xfe, 0x09, 0xfc, 0xbf, 0x66, 0x54, 0x29, 0xb8, 0x42, 0xf2, 0x04, 0x86, 0xac, 0x62, 0x69, 0xce, 0x6e, 0x72, 0xb4, 0x6b, 0x6d, 0xd1, 0x5f, 0x84, 0xff, 0xb9, 0x03, 0x8f, 0x2e, 0x52, 0x55, 0x32, 0x1d, 0xaf, 0x8c, 0x91, 0x46, 0x88, 0x1c, 0x43, 0xd7, 0xf8, 0xb4, 0x17, 0x46, 0xa7, 0xe3, 0xc0, 0xa4, 0xd5, 0x1a, 0xa5, 0xb6, 0x64, 0x56, 0x47, 0x1e, 0x8b, 0x04, 0x93, 0xa8, 0xcc, 0x19, 0xb7, 0xc6, 0x3c, 0x3a, 0x6a, 0xb8, 0x30, 0x67, 0xdc, 0xac, 0xae, 0xd3, 0x02, 0xc5, 0xad, 0x6e, 0x8c, 0xb5, 0x90, 0x3c, 0x83, 0x81, 0xc4, 0x65, 0x2a, 0xb8, 0x31, 0xe5, 0xce, 0x47, 0xa7, 0xfb, 0xc1, 0x66, 0xd4, 0xd4, 0xd6, 0x16, 0xfc, 0x9d, 0xa0, 0x6d, 0x1f, 0x39, 0x02, 0x50, 0xf1, 0x0a, 0x0b, 0x16, 0x55, 0x28, 0x27, 0x3d, 0xab, 0x37, 0xac, 0x99, 0xd7, 0x28, 0xc9, 0x0b, 0x18, 0x6b, 0x63, 0x29, 0x6a, 0x75, 0xfb, 0x56, 0xf7, 0xe0, 0x9e, 0xee, 0xb5, 0xe9, 0xa8, 0xc5, 0x15, 0xf5, 0xf4, 0x06, 0xf2, 0x0b, 0xd8, 0xbb, 0x1f, 0x44, 0x93, 0xdf, 0x0c, 0x7a, 0x28, 0xa5, 0x90, 0x4d, 0x14, 0x60, 0xa3, 0xb8, 0x34, 0x0c, 0xad, 0x0b, 0xe4, 0x0c, 0xc6, 0x12, 0xb5, 0xfc, 0xb0, 0x9e, 0xdc, 0xb1, 0x93, 0xb7, 0x83, 0xe6, 0xa5, 0xd4, 0x13, 0xa8, 0x67, 0x9b, 0xda, 0x71, 0x6f, 0x60, 0xf7, 0x9c, 0xf1, 0x18, 0xf3, 0x7f, 0x4c, 0x7d, 0xbd, 0x4e, 0xe7, 0x81, 0x75, 0xfc, 0xe7, 0x40, 0x36, 0x95, 0xff, 0xd6, 0x86, 0xff, 0xc9, 0x81, 0xa3, 0x4b, 0x65, 0x32, 0x49, 0xd5, 0xea, 0x2a, 0x0c, 0xcf, 0x05, 0xe7, 0x18, 0x9b, 0x47, 0xd8, 0xae, 0x17, 0xc0, 0x48, 0x21, 0x4f, 0x50, 0x46, 0x0f, 0x6f, 0x09, 0x75, 0x87, 0xfd, 0x43, 0x9c, 0x9a, 0x60, 0x62, 0x4c, 0xab, 0xf6, 0x46, 0xe7, 0x77, 0x37, 0xbc, 0xb6, 0xc7, 0x20, 0xff, 0x2d, 0x8c, 0xaf, 0xc2, 0xf0, 0x82, 0x69, 0x16, 0xb2, 0x38, 0x43, 0x4d, 0x08, 0x74, 0x13, 0xd6, 0x4c, 0xf3, 0xa8, 0x3d, 0xff, 0x39, 0x04, 0xf2, 0x18, 0xfa, 0xf1, 0xea, 0x96, 0x67, 0x6a, 0xe2, 0xce, 0xdc, 0xb9, 0x47, 0x1b, 0xe4, 0x3f, 0x85, 0x9e, 0xed, 0x33, 0xb2, 0xe6, 0x9d, 0x5a, 0xd9, 0x1e, 0xb5, 0x67, 0xb2, 0x03, 0x6e, 0xa1, 0x96, 0x56, 0x74, 0x48, 0xcd, 0xf1, 0x95, 0xff, 0xf5, 0x6e, 0xea, 0x7c, 0xbb, 0x9b, 0x3a, 0xdf, 0xef, 0xa6, 0xce, 0x97, 0x1f, 0xd3, 0xff, 0x60, 0x47, 0xc8, 0x65, 0xa0, 0xd3, 0xac, 0x0a, 0xb2, 0xca, 0x7e, 0x02, 0x6e, 0xfa, 0xf6, 0xe7, 0xec, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6c, 0x96, 0x0a, 0x28, 0x52, 0x04, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/pdpb/000077500000000000000000000000001421456440000160135ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/pdpb/pdpb.pb.go000066400000000000000000024364361421456440000177110ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: pdpb.proto package pdpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" eraftpb "github.com/pingcap/kvproto/pkg/eraftpb" metapb "github.com/pingcap/kvproto/pkg/metapb" raft_serverpb "github.com/pingcap/kvproto/pkg/raft_serverpb" replication_modepb "github.com/pingcap/kvproto/pkg/replication_modepb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type ErrorType int32 const ( ErrorType_OK ErrorType = 0 ErrorType_UNKNOWN ErrorType = 1 ErrorType_NOT_BOOTSTRAPPED ErrorType = 2 ErrorType_STORE_TOMBSTONE ErrorType = 3 ErrorType_ALREADY_BOOTSTRAPPED ErrorType = 4 ErrorType_INCOMPATIBLE_VERSION ErrorType = 5 ErrorType_REGION_NOT_FOUND ErrorType = 6 ErrorType_GLOBAL_CONFIG_NOT_FOUND ErrorType = 7 ) var ErrorType_name = map[int32]string{ 0: "OK", 1: "UNKNOWN", 2: "NOT_BOOTSTRAPPED", 3: "STORE_TOMBSTONE", 4: "ALREADY_BOOTSTRAPPED", 5: "INCOMPATIBLE_VERSION", 6: "REGION_NOT_FOUND", 7: "GLOBAL_CONFIG_NOT_FOUND", } var ErrorType_value = map[string]int32{ "OK": 0, "UNKNOWN": 1, "NOT_BOOTSTRAPPED": 2, "STORE_TOMBSTONE": 3, "ALREADY_BOOTSTRAPPED": 4, "INCOMPATIBLE_VERSION": 5, "REGION_NOT_FOUND": 6, "GLOBAL_CONFIG_NOT_FOUND": 7, } func (x ErrorType) String() string { return proto.EnumName(ErrorType_name, int32(x)) } func (ErrorType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{0} } type CheckPolicy int32 const ( CheckPolicy_SCAN CheckPolicy = 0 CheckPolicy_APPROXIMATE CheckPolicy = 1 CheckPolicy_USEKEY CheckPolicy = 2 ) var CheckPolicy_name = map[int32]string{ 0: "SCAN", 1: "APPROXIMATE", 2: "USEKEY", } var CheckPolicy_value = map[string]int32{ "SCAN": 0, "APPROXIMATE": 1, "USEKEY": 2, } func (x CheckPolicy) String() string { return proto.EnumName(CheckPolicy_name, int32(x)) } func (CheckPolicy) EnumDescriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{1} } type OperatorStatus int32 const ( OperatorStatus_SUCCESS OperatorStatus = 0 OperatorStatus_TIMEOUT OperatorStatus = 1 OperatorStatus_CANCEL OperatorStatus = 2 OperatorStatus_REPLACE OperatorStatus = 3 OperatorStatus_RUNNING OperatorStatus = 4 ) var OperatorStatus_name = map[int32]string{ 0: "SUCCESS", 1: "TIMEOUT", 2: "CANCEL", 3: "REPLACE", 4: "RUNNING", } var OperatorStatus_value = map[string]int32{ "SUCCESS": 0, "TIMEOUT": 1, "CANCEL": 2, "REPLACE": 3, "RUNNING": 4, } func (x OperatorStatus) String() string { return proto.EnumName(OperatorStatus_name, int32(x)) } func (OperatorStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{2} } type QueryKind int32 const ( QueryKind_Others QueryKind = 0 QueryKind_GC QueryKind = 1 QueryKind_Get QueryKind = 2 QueryKind_Scan QueryKind = 3 QueryKind_Coprocessor QueryKind = 4 QueryKind_Delete QueryKind = 5 QueryKind_DeleteRange QueryKind = 6 QueryKind_Put QueryKind = 7 QueryKind_Prewrite QueryKind = 8 QueryKind_AcquirePessimisticLock QueryKind = 9 QueryKind_Commit QueryKind = 10 QueryKind_Rollback QueryKind = 11 ) var QueryKind_name = map[int32]string{ 0: "Others", 1: "GC", 2: "Get", 3: "Scan", 4: "Coprocessor", 5: "Delete", 6: "DeleteRange", 7: "Put", 8: "Prewrite", 9: "AcquirePessimisticLock", 10: "Commit", 11: "Rollback", } var QueryKind_value = map[string]int32{ "Others": 0, "GC": 1, "Get": 2, "Scan": 3, "Coprocessor": 4, "Delete": 5, "DeleteRange": 6, "Put": 7, "Prewrite": 8, "AcquirePessimisticLock": 9, "Commit": 10, "Rollback": 11, } func (x QueryKind) String() string { return proto.EnumName(QueryKind_name, int32(x)) } func (QueryKind) EnumDescriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{3} } type WatchGlobalConfigRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WatchGlobalConfigRequest) Reset() { *m = WatchGlobalConfigRequest{} } func (m *WatchGlobalConfigRequest) String() string { return proto.CompactTextString(m) } func (*WatchGlobalConfigRequest) ProtoMessage() {} func (*WatchGlobalConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{0} } func (m *WatchGlobalConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WatchGlobalConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WatchGlobalConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WatchGlobalConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_WatchGlobalConfigRequest.Merge(dst, src) } func (m *WatchGlobalConfigRequest) XXX_Size() int { return m.Size() } func (m *WatchGlobalConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_WatchGlobalConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_WatchGlobalConfigRequest proto.InternalMessageInfo type WatchGlobalConfigResponse struct { Changes []*GlobalConfigItem `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WatchGlobalConfigResponse) Reset() { *m = WatchGlobalConfigResponse{} } func (m *WatchGlobalConfigResponse) String() string { return proto.CompactTextString(m) } func (*WatchGlobalConfigResponse) ProtoMessage() {} func (*WatchGlobalConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{1} } func (m *WatchGlobalConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WatchGlobalConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WatchGlobalConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *WatchGlobalConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_WatchGlobalConfigResponse.Merge(dst, src) } func (m *WatchGlobalConfigResponse) XXX_Size() int { return m.Size() } func (m *WatchGlobalConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_WatchGlobalConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_WatchGlobalConfigResponse proto.InternalMessageInfo func (m *WatchGlobalConfigResponse) GetChanges() []*GlobalConfigItem { if m != nil { return m.Changes } return nil } type StoreGlobalConfigRequest struct { Changes []*GlobalConfigItem `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreGlobalConfigRequest) Reset() { *m = StoreGlobalConfigRequest{} } func (m *StoreGlobalConfigRequest) String() string { return proto.CompactTextString(m) } func (*StoreGlobalConfigRequest) ProtoMessage() {} func (*StoreGlobalConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{2} } func (m *StoreGlobalConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreGlobalConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreGlobalConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreGlobalConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreGlobalConfigRequest.Merge(dst, src) } func (m *StoreGlobalConfigRequest) XXX_Size() int { return m.Size() } func (m *StoreGlobalConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_StoreGlobalConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_StoreGlobalConfigRequest proto.InternalMessageInfo func (m *StoreGlobalConfigRequest) GetChanges() []*GlobalConfigItem { if m != nil { return m.Changes } return nil } type StoreGlobalConfigResponse struct { Error *Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreGlobalConfigResponse) Reset() { *m = StoreGlobalConfigResponse{} } func (m *StoreGlobalConfigResponse) String() string { return proto.CompactTextString(m) } func (*StoreGlobalConfigResponse) ProtoMessage() {} func (*StoreGlobalConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{3} } func (m *StoreGlobalConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreGlobalConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreGlobalConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreGlobalConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreGlobalConfigResponse.Merge(dst, src) } func (m *StoreGlobalConfigResponse) XXX_Size() int { return m.Size() } func (m *StoreGlobalConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_StoreGlobalConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_StoreGlobalConfigResponse proto.InternalMessageInfo func (m *StoreGlobalConfigResponse) GetError() *Error { if m != nil { return m.Error } return nil } type LoadGlobalConfigRequest struct { Names []string `protobuf:"bytes,1,rep,name=names" json:"names,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LoadGlobalConfigRequest) Reset() { *m = LoadGlobalConfigRequest{} } func (m *LoadGlobalConfigRequest) String() string { return proto.CompactTextString(m) } func (*LoadGlobalConfigRequest) ProtoMessage() {} func (*LoadGlobalConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{4} } func (m *LoadGlobalConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LoadGlobalConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LoadGlobalConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LoadGlobalConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_LoadGlobalConfigRequest.Merge(dst, src) } func (m *LoadGlobalConfigRequest) XXX_Size() int { return m.Size() } func (m *LoadGlobalConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_LoadGlobalConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_LoadGlobalConfigRequest proto.InternalMessageInfo func (m *LoadGlobalConfigRequest) GetNames() []string { if m != nil { return m.Names } return nil } type LoadGlobalConfigResponse struct { Items []*GlobalConfigItem `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LoadGlobalConfigResponse) Reset() { *m = LoadGlobalConfigResponse{} } func (m *LoadGlobalConfigResponse) String() string { return proto.CompactTextString(m) } func (*LoadGlobalConfigResponse) ProtoMessage() {} func (*LoadGlobalConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{5} } func (m *LoadGlobalConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LoadGlobalConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LoadGlobalConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *LoadGlobalConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_LoadGlobalConfigResponse.Merge(dst, src) } func (m *LoadGlobalConfigResponse) XXX_Size() int { return m.Size() } func (m *LoadGlobalConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_LoadGlobalConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_LoadGlobalConfigResponse proto.InternalMessageInfo func (m *LoadGlobalConfigResponse) GetItems() []*GlobalConfigItem { if m != nil { return m.Items } return nil } type GlobalConfigItem struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` Error *Error `protobuf:"bytes,3,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GlobalConfigItem) Reset() { *m = GlobalConfigItem{} } func (m *GlobalConfigItem) String() string { return proto.CompactTextString(m) } func (*GlobalConfigItem) ProtoMessage() {} func (*GlobalConfigItem) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{6} } func (m *GlobalConfigItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GlobalConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GlobalConfigItem.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GlobalConfigItem) XXX_Merge(src proto.Message) { xxx_messageInfo_GlobalConfigItem.Merge(dst, src) } func (m *GlobalConfigItem) XXX_Size() int { return m.Size() } func (m *GlobalConfigItem) XXX_DiscardUnknown() { xxx_messageInfo_GlobalConfigItem.DiscardUnknown(m) } var xxx_messageInfo_GlobalConfigItem proto.InternalMessageInfo func (m *GlobalConfigItem) GetName() string { if m != nil { return m.Name } return "" } func (m *GlobalConfigItem) GetValue() string { if m != nil { return m.Value } return "" } func (m *GlobalConfigItem) GetError() *Error { if m != nil { return m.Error } return nil } type RequestHeader struct { // cluster_id is the ID of the cluster which be sent to. ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` // sender_id is the ID of the sender server, also member ID or etcd ID. SenderId uint64 `protobuf:"varint,2,opt,name=sender_id,json=senderId,proto3" json:"sender_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RequestHeader) Reset() { *m = RequestHeader{} } func (m *RequestHeader) String() string { return proto.CompactTextString(m) } func (*RequestHeader) ProtoMessage() {} func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{7} } func (m *RequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RequestHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RequestHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RequestHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_RequestHeader.Merge(dst, src) } func (m *RequestHeader) XXX_Size() int { return m.Size() } func (m *RequestHeader) XXX_DiscardUnknown() { xxx_messageInfo_RequestHeader.DiscardUnknown(m) } var xxx_messageInfo_RequestHeader proto.InternalMessageInfo func (m *RequestHeader) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *RequestHeader) GetSenderId() uint64 { if m != nil { return m.SenderId } return 0 } type ResponseHeader struct { // cluster_id is the ID of the cluster which sent the response. ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } func (*ResponseHeader) ProtoMessage() {} func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{8} } func (m *ResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResponseHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResponseHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_ResponseHeader.Merge(dst, src) } func (m *ResponseHeader) XXX_Size() int { return m.Size() } func (m *ResponseHeader) XXX_DiscardUnknown() { xxx_messageInfo_ResponseHeader.DiscardUnknown(m) } var xxx_messageInfo_ResponseHeader proto.InternalMessageInfo func (m *ResponseHeader) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *ResponseHeader) GetError() *Error { if m != nil { return m.Error } return nil } type Error struct { Type ErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=pdpb.ErrorType" json:"type,omitempty"` Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{9} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Error) XXX_Merge(src proto.Message) { xxx_messageInfo_Error.Merge(dst, src) } func (m *Error) XXX_Size() int { return m.Size() } func (m *Error) XXX_DiscardUnknown() { xxx_messageInfo_Error.DiscardUnknown(m) } var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetType() ErrorType { if m != nil { return m.Type } return ErrorType_OK } func (m *Error) GetMessage() string { if m != nil { return m.Message } return "" } type TsoRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` DcLocation string `protobuf:"bytes,3,opt,name=dc_location,json=dcLocation,proto3" json:"dc_location,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TsoRequest) Reset() { *m = TsoRequest{} } func (m *TsoRequest) String() string { return proto.CompactTextString(m) } func (*TsoRequest) ProtoMessage() {} func (*TsoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{10} } func (m *TsoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TsoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TsoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TsoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_TsoRequest.Merge(dst, src) } func (m *TsoRequest) XXX_Size() int { return m.Size() } func (m *TsoRequest) XXX_DiscardUnknown() { xxx_messageInfo_TsoRequest.DiscardUnknown(m) } var xxx_messageInfo_TsoRequest proto.InternalMessageInfo func (m *TsoRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *TsoRequest) GetCount() uint32 { if m != nil { return m.Count } return 0 } func (m *TsoRequest) GetDcLocation() string { if m != nil { return m.DcLocation } return "" } type Timestamp struct { Physical int64 `protobuf:"varint,1,opt,name=physical,proto3" json:"physical,omitempty"` Logical int64 `protobuf:"varint,2,opt,name=logical,proto3" json:"logical,omitempty"` // Number of suffix bits used for global distinction, // PD client will use this to compute a TSO's logical part. SuffixBits uint32 `protobuf:"varint,3,opt,name=suffix_bits,json=suffixBits,proto3" json:"suffix_bits,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Timestamp) Reset() { *m = Timestamp{} } func (m *Timestamp) String() string { return proto.CompactTextString(m) } func (*Timestamp) ProtoMessage() {} func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{11} } func (m *Timestamp) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Timestamp) XXX_Merge(src proto.Message) { xxx_messageInfo_Timestamp.Merge(dst, src) } func (m *Timestamp) XXX_Size() int { return m.Size() } func (m *Timestamp) XXX_DiscardUnknown() { xxx_messageInfo_Timestamp.DiscardUnknown(m) } var xxx_messageInfo_Timestamp proto.InternalMessageInfo func (m *Timestamp) GetPhysical() int64 { if m != nil { return m.Physical } return 0 } func (m *Timestamp) GetLogical() int64 { if m != nil { return m.Logical } return 0 } func (m *Timestamp) GetSuffixBits() uint32 { if m != nil { return m.SuffixBits } return 0 } type TsoResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` Timestamp *Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TsoResponse) Reset() { *m = TsoResponse{} } func (m *TsoResponse) String() string { return proto.CompactTextString(m) } func (*TsoResponse) ProtoMessage() {} func (*TsoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{12} } func (m *TsoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TsoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TsoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TsoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_TsoResponse.Merge(dst, src) } func (m *TsoResponse) XXX_Size() int { return m.Size() } func (m *TsoResponse) XXX_DiscardUnknown() { xxx_messageInfo_TsoResponse.DiscardUnknown(m) } var xxx_messageInfo_TsoResponse proto.InternalMessageInfo func (m *TsoResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *TsoResponse) GetCount() uint32 { if m != nil { return m.Count } return 0 } func (m *TsoResponse) GetTimestamp() *Timestamp { if m != nil { return m.Timestamp } return nil } type BootstrapRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BootstrapRequest) Reset() { *m = BootstrapRequest{} } func (m *BootstrapRequest) String() string { return proto.CompactTextString(m) } func (*BootstrapRequest) ProtoMessage() {} func (*BootstrapRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{13} } func (m *BootstrapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BootstrapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BootstrapRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BootstrapRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BootstrapRequest.Merge(dst, src) } func (m *BootstrapRequest) XXX_Size() int { return m.Size() } func (m *BootstrapRequest) XXX_DiscardUnknown() { xxx_messageInfo_BootstrapRequest.DiscardUnknown(m) } var xxx_messageInfo_BootstrapRequest proto.InternalMessageInfo func (m *BootstrapRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *BootstrapRequest) GetStore() *metapb.Store { if m != nil { return m.Store } return nil } func (m *BootstrapRequest) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } type BootstrapResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BootstrapResponse) Reset() { *m = BootstrapResponse{} } func (m *BootstrapResponse) String() string { return proto.CompactTextString(m) } func (*BootstrapResponse) ProtoMessage() {} func (*BootstrapResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{14} } func (m *BootstrapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BootstrapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BootstrapResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BootstrapResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BootstrapResponse.Merge(dst, src) } func (m *BootstrapResponse) XXX_Size() int { return m.Size() } func (m *BootstrapResponse) XXX_DiscardUnknown() { xxx_messageInfo_BootstrapResponse.DiscardUnknown(m) } var xxx_messageInfo_BootstrapResponse proto.InternalMessageInfo func (m *BootstrapResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *BootstrapResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { return m.ReplicationStatus } return nil } type IsBootstrappedRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IsBootstrappedRequest) Reset() { *m = IsBootstrappedRequest{} } func (m *IsBootstrappedRequest) String() string { return proto.CompactTextString(m) } func (*IsBootstrappedRequest) ProtoMessage() {} func (*IsBootstrappedRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{15} } func (m *IsBootstrappedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IsBootstrappedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IsBootstrappedRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IsBootstrappedRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_IsBootstrappedRequest.Merge(dst, src) } func (m *IsBootstrappedRequest) XXX_Size() int { return m.Size() } func (m *IsBootstrappedRequest) XXX_DiscardUnknown() { xxx_messageInfo_IsBootstrappedRequest.DiscardUnknown(m) } var xxx_messageInfo_IsBootstrappedRequest proto.InternalMessageInfo func (m *IsBootstrappedRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } type IsBootstrappedResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Bootstrapped bool `protobuf:"varint,2,opt,name=bootstrapped,proto3" json:"bootstrapped,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IsBootstrappedResponse) Reset() { *m = IsBootstrappedResponse{} } func (m *IsBootstrappedResponse) String() string { return proto.CompactTextString(m) } func (*IsBootstrappedResponse) ProtoMessage() {} func (*IsBootstrappedResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{16} } func (m *IsBootstrappedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IsBootstrappedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IsBootstrappedResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IsBootstrappedResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_IsBootstrappedResponse.Merge(dst, src) } func (m *IsBootstrappedResponse) XXX_Size() int { return m.Size() } func (m *IsBootstrappedResponse) XXX_DiscardUnknown() { xxx_messageInfo_IsBootstrappedResponse.DiscardUnknown(m) } var xxx_messageInfo_IsBootstrappedResponse proto.InternalMessageInfo func (m *IsBootstrappedResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *IsBootstrappedResponse) GetBootstrapped() bool { if m != nil { return m.Bootstrapped } return false } type AllocIDRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AllocIDRequest) Reset() { *m = AllocIDRequest{} } func (m *AllocIDRequest) String() string { return proto.CompactTextString(m) } func (*AllocIDRequest) ProtoMessage() {} func (*AllocIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{17} } func (m *AllocIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AllocIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AllocIDRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AllocIDRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AllocIDRequest.Merge(dst, src) } func (m *AllocIDRequest) XXX_Size() int { return m.Size() } func (m *AllocIDRequest) XXX_DiscardUnknown() { xxx_messageInfo_AllocIDRequest.DiscardUnknown(m) } var xxx_messageInfo_AllocIDRequest proto.InternalMessageInfo func (m *AllocIDRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } type AllocIDResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AllocIDResponse) Reset() { *m = AllocIDResponse{} } func (m *AllocIDResponse) String() string { return proto.CompactTextString(m) } func (*AllocIDResponse) ProtoMessage() {} func (*AllocIDResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{18} } func (m *AllocIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AllocIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AllocIDResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AllocIDResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_AllocIDResponse.Merge(dst, src) } func (m *AllocIDResponse) XXX_Size() int { return m.Size() } func (m *AllocIDResponse) XXX_DiscardUnknown() { xxx_messageInfo_AllocIDResponse.DiscardUnknown(m) } var xxx_messageInfo_AllocIDResponse proto.InternalMessageInfo func (m *AllocIDResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *AllocIDResponse) GetId() uint64 { if m != nil { return m.Id } return 0 } type GetStoreRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetStoreRequest) Reset() { *m = GetStoreRequest{} } func (m *GetStoreRequest) String() string { return proto.CompactTextString(m) } func (*GetStoreRequest) ProtoMessage() {} func (*GetStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{19} } func (m *GetStoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetStoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetStoreRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetStoreRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetStoreRequest.Merge(dst, src) } func (m *GetStoreRequest) XXX_Size() int { return m.Size() } func (m *GetStoreRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetStoreRequest.DiscardUnknown(m) } var xxx_messageInfo_GetStoreRequest proto.InternalMessageInfo func (m *GetStoreRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetStoreRequest) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } type GetStoreResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` Stats *StoreStats `protobuf:"bytes,3,opt,name=stats" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetStoreResponse) Reset() { *m = GetStoreResponse{} } func (m *GetStoreResponse) String() string { return proto.CompactTextString(m) } func (*GetStoreResponse) ProtoMessage() {} func (*GetStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{20} } func (m *GetStoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetStoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetStoreResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetStoreResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetStoreResponse.Merge(dst, src) } func (m *GetStoreResponse) XXX_Size() int { return m.Size() } func (m *GetStoreResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetStoreResponse.DiscardUnknown(m) } var xxx_messageInfo_GetStoreResponse proto.InternalMessageInfo func (m *GetStoreResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetStoreResponse) GetStore() *metapb.Store { if m != nil { return m.Store } return nil } func (m *GetStoreResponse) GetStats() *StoreStats { if m != nil { return m.Stats } return nil } type PutStoreRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutStoreRequest) Reset() { *m = PutStoreRequest{} } func (m *PutStoreRequest) String() string { return proto.CompactTextString(m) } func (*PutStoreRequest) ProtoMessage() {} func (*PutStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{21} } func (m *PutStoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutStoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutStoreRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutStoreRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PutStoreRequest.Merge(dst, src) } func (m *PutStoreRequest) XXX_Size() int { return m.Size() } func (m *PutStoreRequest) XXX_DiscardUnknown() { xxx_messageInfo_PutStoreRequest.DiscardUnknown(m) } var xxx_messageInfo_PutStoreRequest proto.InternalMessageInfo func (m *PutStoreRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *PutStoreRequest) GetStore() *metapb.Store { if m != nil { return m.Store } return nil } type PutStoreResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutStoreResponse) Reset() { *m = PutStoreResponse{} } func (m *PutStoreResponse) String() string { return proto.CompactTextString(m) } func (*PutStoreResponse) ProtoMessage() {} func (*PutStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{22} } func (m *PutStoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutStoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutStoreResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutStoreResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PutStoreResponse.Merge(dst, src) } func (m *PutStoreResponse) XXX_Size() int { return m.Size() } func (m *PutStoreResponse) XXX_DiscardUnknown() { xxx_messageInfo_PutStoreResponse.DiscardUnknown(m) } var xxx_messageInfo_PutStoreResponse proto.InternalMessageInfo func (m *PutStoreResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *PutStoreResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { return m.ReplicationStatus } return nil } type GetAllStoresRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // Do NOT return tombstone stores if set to true. ExcludeTombstoneStores bool `protobuf:"varint,2,opt,name=exclude_tombstone_stores,json=excludeTombstoneStores,proto3" json:"exclude_tombstone_stores,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllStoresRequest) Reset() { *m = GetAllStoresRequest{} } func (m *GetAllStoresRequest) String() string { return proto.CompactTextString(m) } func (*GetAllStoresRequest) ProtoMessage() {} func (*GetAllStoresRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{23} } func (m *GetAllStoresRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllStoresRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllStoresRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllStoresRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllStoresRequest.Merge(dst, src) } func (m *GetAllStoresRequest) XXX_Size() int { return m.Size() } func (m *GetAllStoresRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetAllStoresRequest.DiscardUnknown(m) } var xxx_messageInfo_GetAllStoresRequest proto.InternalMessageInfo func (m *GetAllStoresRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetAllStoresRequest) GetExcludeTombstoneStores() bool { if m != nil { return m.ExcludeTombstoneStores } return false } type GetAllStoresResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Stores []*metapb.Store `protobuf:"bytes,2,rep,name=stores" json:"stores,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetAllStoresResponse) Reset() { *m = GetAllStoresResponse{} } func (m *GetAllStoresResponse) String() string { return proto.CompactTextString(m) } func (*GetAllStoresResponse) ProtoMessage() {} func (*GetAllStoresResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{24} } func (m *GetAllStoresResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetAllStoresResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetAllStoresResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetAllStoresResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetAllStoresResponse.Merge(dst, src) } func (m *GetAllStoresResponse) XXX_Size() int { return m.Size() } func (m *GetAllStoresResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetAllStoresResponse.DiscardUnknown(m) } var xxx_messageInfo_GetAllStoresResponse proto.InternalMessageInfo func (m *GetAllStoresResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetAllStoresResponse) GetStores() []*metapb.Store { if m != nil { return m.Stores } return nil } type GetRegionRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionKey []byte `protobuf:"bytes,2,opt,name=region_key,json=regionKey,proto3" json:"region_key,omitempty"` NeedBuckets bool `protobuf:"varint,3,opt,name=need_buckets,json=needBuckets,proto3" json:"need_buckets,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRegionRequest) Reset() { *m = GetRegionRequest{} } func (m *GetRegionRequest) String() string { return proto.CompactTextString(m) } func (*GetRegionRequest) ProtoMessage() {} func (*GetRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{25} } func (m *GetRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRegionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRegionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRegionRequest.Merge(dst, src) } func (m *GetRegionRequest) XXX_Size() int { return m.Size() } func (m *GetRegionRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetRegionRequest.DiscardUnknown(m) } var xxx_messageInfo_GetRegionRequest proto.InternalMessageInfo func (m *GetRegionRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetRegionRequest) GetRegionKey() []byte { if m != nil { return m.RegionKey } return nil } func (m *GetRegionRequest) GetNeedBuckets() bool { if m != nil { return m.NeedBuckets } return false } type GetRegionResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` // Leader considers that these peers are down. DownPeers []*PeerStats `protobuf:"bytes,5,rep,name=down_peers,json=downPeers" json:"down_peers,omitempty"` // Pending peers are the peers that the leader can't consider as // working followers. PendingPeers []*metapb.Peer `protobuf:"bytes,6,rep,name=pending_peers,json=pendingPeers" json:"pending_peers,omitempty"` // buckets isn't nil if GetRegion.* requests set need_buckets. Buckets *metapb.Buckets `protobuf:"bytes,7,opt,name=buckets" json:"buckets,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRegionResponse) Reset() { *m = GetRegionResponse{} } func (m *GetRegionResponse) String() string { return proto.CompactTextString(m) } func (*GetRegionResponse) ProtoMessage() {} func (*GetRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{26} } func (m *GetRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRegionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRegionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRegionResponse.Merge(dst, src) } func (m *GetRegionResponse) XXX_Size() int { return m.Size() } func (m *GetRegionResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetRegionResponse.DiscardUnknown(m) } var xxx_messageInfo_GetRegionResponse proto.InternalMessageInfo func (m *GetRegionResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetRegionResponse) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *GetRegionResponse) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } func (m *GetRegionResponse) GetDownPeers() []*PeerStats { if m != nil { return m.DownPeers } return nil } func (m *GetRegionResponse) GetPendingPeers() []*metapb.Peer { if m != nil { return m.PendingPeers } return nil } func (m *GetRegionResponse) GetBuckets() *metapb.Buckets { if m != nil { return m.Buckets } return nil } type GetRegionByIDRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` NeedBuckets bool `protobuf:"varint,3,opt,name=need_buckets,json=needBuckets,proto3" json:"need_buckets,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRegionByIDRequest) Reset() { *m = GetRegionByIDRequest{} } func (m *GetRegionByIDRequest) String() string { return proto.CompactTextString(m) } func (*GetRegionByIDRequest) ProtoMessage() {} func (*GetRegionByIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{27} } func (m *GetRegionByIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetRegionByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetRegionByIDRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRegionByIDRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRegionByIDRequest.Merge(dst, src) } func (m *GetRegionByIDRequest) XXX_Size() int { return m.Size() } func (m *GetRegionByIDRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetRegionByIDRequest.DiscardUnknown(m) } var xxx_messageInfo_GetRegionByIDRequest proto.InternalMessageInfo func (m *GetRegionByIDRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetRegionByIDRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *GetRegionByIDRequest) GetNeedBuckets() bool { if m != nil { return m.NeedBuckets } return false } type ScanRegionsRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanRegionsRequest) Reset() { *m = ScanRegionsRequest{} } func (m *ScanRegionsRequest) String() string { return proto.CompactTextString(m) } func (*ScanRegionsRequest) ProtoMessage() {} func (*ScanRegionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{28} } func (m *ScanRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanRegionsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanRegionsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanRegionsRequest.Merge(dst, src) } func (m *ScanRegionsRequest) XXX_Size() int { return m.Size() } func (m *ScanRegionsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ScanRegionsRequest.DiscardUnknown(m) } var xxx_messageInfo_ScanRegionsRequest proto.InternalMessageInfo func (m *ScanRegionsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *ScanRegionsRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *ScanRegionsRequest) GetLimit() int32 { if m != nil { return m.Limit } return 0 } func (m *ScanRegionsRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } type Region struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` Leader *metapb.Peer `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"` // Leader considers that these peers are down. DownPeers []*PeerStats `protobuf:"bytes,3,rep,name=down_peers,json=downPeers" json:"down_peers,omitempty"` // Pending peers are the peers that the leader can't consider as // working followers. PendingPeers []*metapb.Peer `protobuf:"bytes,4,rep,name=pending_peers,json=pendingPeers" json:"pending_peers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Region) Reset() { *m = Region{} } func (m *Region) String() string { return proto.CompactTextString(m) } func (*Region) ProtoMessage() {} func (*Region) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{29} } func (m *Region) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Region) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Region.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Region) XXX_Merge(src proto.Message) { xxx_messageInfo_Region.Merge(dst, src) } func (m *Region) XXX_Size() int { return m.Size() } func (m *Region) XXX_DiscardUnknown() { xxx_messageInfo_Region.DiscardUnknown(m) } var xxx_messageInfo_Region proto.InternalMessageInfo func (m *Region) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *Region) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } func (m *Region) GetDownPeers() []*PeerStats { if m != nil { return m.DownPeers } return nil } func (m *Region) GetPendingPeers() []*metapb.Peer { if m != nil { return m.PendingPeers } return nil } type ScanRegionsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // Keep for backword compatibability. RegionMetas []*metapb.Region `protobuf:"bytes,2,rep,name=region_metas,json=regionMetas" json:"region_metas,omitempty"` Leaders []*metapb.Peer `protobuf:"bytes,3,rep,name=leaders" json:"leaders,omitempty"` // Extended region info with down/pending peers. Regions []*Region `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScanRegionsResponse) Reset() { *m = ScanRegionsResponse{} } func (m *ScanRegionsResponse) String() string { return proto.CompactTextString(m) } func (*ScanRegionsResponse) ProtoMessage() {} func (*ScanRegionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{30} } func (m *ScanRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScanRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScanRegionsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScanRegionsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ScanRegionsResponse.Merge(dst, src) } func (m *ScanRegionsResponse) XXX_Size() int { return m.Size() } func (m *ScanRegionsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ScanRegionsResponse.DiscardUnknown(m) } var xxx_messageInfo_ScanRegionsResponse proto.InternalMessageInfo func (m *ScanRegionsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *ScanRegionsResponse) GetRegionMetas() []*metapb.Region { if m != nil { return m.RegionMetas } return nil } func (m *ScanRegionsResponse) GetLeaders() []*metapb.Peer { if m != nil { return m.Leaders } return nil } func (m *ScanRegionsResponse) GetRegions() []*Region { if m != nil { return m.Regions } return nil } type GetClusterConfigRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetClusterConfigRequest) Reset() { *m = GetClusterConfigRequest{} } func (m *GetClusterConfigRequest) String() string { return proto.CompactTextString(m) } func (*GetClusterConfigRequest) ProtoMessage() {} func (*GetClusterConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{31} } func (m *GetClusterConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetClusterConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetClusterConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetClusterConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetClusterConfigRequest.Merge(dst, src) } func (m *GetClusterConfigRequest) XXX_Size() int { return m.Size() } func (m *GetClusterConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetClusterConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_GetClusterConfigRequest proto.InternalMessageInfo func (m *GetClusterConfigRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } type GetClusterConfigResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetClusterConfigResponse) Reset() { *m = GetClusterConfigResponse{} } func (m *GetClusterConfigResponse) String() string { return proto.CompactTextString(m) } func (*GetClusterConfigResponse) ProtoMessage() {} func (*GetClusterConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{32} } func (m *GetClusterConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetClusterConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetClusterConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetClusterConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetClusterConfigResponse.Merge(dst, src) } func (m *GetClusterConfigResponse) XXX_Size() int { return m.Size() } func (m *GetClusterConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetClusterConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_GetClusterConfigResponse proto.InternalMessageInfo func (m *GetClusterConfigResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetClusterConfigResponse) GetCluster() *metapb.Cluster { if m != nil { return m.Cluster } return nil } type PutClusterConfigRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutClusterConfigRequest) Reset() { *m = PutClusterConfigRequest{} } func (m *PutClusterConfigRequest) String() string { return proto.CompactTextString(m) } func (*PutClusterConfigRequest) ProtoMessage() {} func (*PutClusterConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{33} } func (m *PutClusterConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutClusterConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutClusterConfigRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutClusterConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PutClusterConfigRequest.Merge(dst, src) } func (m *PutClusterConfigRequest) XXX_Size() int { return m.Size() } func (m *PutClusterConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_PutClusterConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_PutClusterConfigRequest proto.InternalMessageInfo func (m *PutClusterConfigRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *PutClusterConfigRequest) GetCluster() *metapb.Cluster { if m != nil { return m.Cluster } return nil } type PutClusterConfigResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutClusterConfigResponse) Reset() { *m = PutClusterConfigResponse{} } func (m *PutClusterConfigResponse) String() string { return proto.CompactTextString(m) } func (*PutClusterConfigResponse) ProtoMessage() {} func (*PutClusterConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{34} } func (m *PutClusterConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutClusterConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutClusterConfigResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutClusterConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PutClusterConfigResponse.Merge(dst, src) } func (m *PutClusterConfigResponse) XXX_Size() int { return m.Size() } func (m *PutClusterConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_PutClusterConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_PutClusterConfigResponse proto.InternalMessageInfo func (m *PutClusterConfigResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } type Member struct { // name is the name of the PD member. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // member_id is the unique id of the PD member. MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"` PeerUrls []string `protobuf:"bytes,3,rep,name=peer_urls,json=peerUrls" json:"peer_urls,omitempty"` ClientUrls []string `protobuf:"bytes,4,rep,name=client_urls,json=clientUrls" json:"client_urls,omitempty"` LeaderPriority int32 `protobuf:"varint,5,opt,name=leader_priority,json=leaderPriority,proto3" json:"leader_priority,omitempty"` DeployPath string `protobuf:"bytes,6,opt,name=deploy_path,json=deployPath,proto3" json:"deploy_path,omitempty"` BinaryVersion string `protobuf:"bytes,7,opt,name=binary_version,json=binaryVersion,proto3" json:"binary_version,omitempty"` GitHash string `protobuf:"bytes,8,opt,name=git_hash,json=gitHash,proto3" json:"git_hash,omitempty"` DcLocation string `protobuf:"bytes,9,opt,name=dc_location,json=dcLocation,proto3" json:"dc_location,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Member) Reset() { *m = Member{} } func (m *Member) String() string { return proto.CompactTextString(m) } func (*Member) ProtoMessage() {} func (*Member) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{35} } func (m *Member) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Member.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Member) XXX_Merge(src proto.Message) { xxx_messageInfo_Member.Merge(dst, src) } func (m *Member) XXX_Size() int { return m.Size() } func (m *Member) XXX_DiscardUnknown() { xxx_messageInfo_Member.DiscardUnknown(m) } var xxx_messageInfo_Member proto.InternalMessageInfo func (m *Member) GetName() string { if m != nil { return m.Name } return "" } func (m *Member) GetMemberId() uint64 { if m != nil { return m.MemberId } return 0 } func (m *Member) GetPeerUrls() []string { if m != nil { return m.PeerUrls } return nil } func (m *Member) GetClientUrls() []string { if m != nil { return m.ClientUrls } return nil } func (m *Member) GetLeaderPriority() int32 { if m != nil { return m.LeaderPriority } return 0 } func (m *Member) GetDeployPath() string { if m != nil { return m.DeployPath } return "" } func (m *Member) GetBinaryVersion() string { if m != nil { return m.BinaryVersion } return "" } func (m *Member) GetGitHash() string { if m != nil { return m.GitHash } return "" } func (m *Member) GetDcLocation() string { if m != nil { return m.DcLocation } return "" } type GetMembersRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMembersRequest) Reset() { *m = GetMembersRequest{} } func (m *GetMembersRequest) String() string { return proto.CompactTextString(m) } func (*GetMembersRequest) ProtoMessage() {} func (*GetMembersRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{36} } func (m *GetMembersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMembersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMembersRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMembersRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMembersRequest.Merge(dst, src) } func (m *GetMembersRequest) XXX_Size() int { return m.Size() } func (m *GetMembersRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetMembersRequest.DiscardUnknown(m) } var xxx_messageInfo_GetMembersRequest proto.InternalMessageInfo func (m *GetMembersRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } type GetMembersResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` Leader *Member `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` EtcdLeader *Member `protobuf:"bytes,4,opt,name=etcd_leader,json=etcdLeader" json:"etcd_leader,omitempty"` TsoAllocatorLeaders map[string]*Member `protobuf:"bytes,5,rep,name=tso_allocator_leaders,json=tsoAllocatorLeaders" json:"tso_allocator_leaders,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetMembersResponse) Reset() { *m = GetMembersResponse{} } func (m *GetMembersResponse) String() string { return proto.CompactTextString(m) } func (*GetMembersResponse) ProtoMessage() {} func (*GetMembersResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{37} } func (m *GetMembersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetMembersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetMembersResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetMembersResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetMembersResponse.Merge(dst, src) } func (m *GetMembersResponse) XXX_Size() int { return m.Size() } func (m *GetMembersResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetMembersResponse.DiscardUnknown(m) } var xxx_messageInfo_GetMembersResponse proto.InternalMessageInfo func (m *GetMembersResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetMembersResponse) GetMembers() []*Member { if m != nil { return m.Members } return nil } func (m *GetMembersResponse) GetLeader() *Member { if m != nil { return m.Leader } return nil } func (m *GetMembersResponse) GetEtcdLeader() *Member { if m != nil { return m.EtcdLeader } return nil } func (m *GetMembersResponse) GetTsoAllocatorLeaders() map[string]*Member { if m != nil { return m.TsoAllocatorLeaders } return nil } type PeerStats struct { Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` DownSeconds uint64 `protobuf:"varint,2,opt,name=down_seconds,json=downSeconds,proto3" json:"down_seconds,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PeerStats) Reset() { *m = PeerStats{} } func (m *PeerStats) String() string { return proto.CompactTextString(m) } func (*PeerStats) ProtoMessage() {} func (*PeerStats) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{38} } func (m *PeerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PeerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PeerStats.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PeerStats) XXX_Merge(src proto.Message) { xxx_messageInfo_PeerStats.Merge(dst, src) } func (m *PeerStats) XXX_Size() int { return m.Size() } func (m *PeerStats) XXX_DiscardUnknown() { xxx_messageInfo_PeerStats.DiscardUnknown(m) } var xxx_messageInfo_PeerStats proto.InternalMessageInfo func (m *PeerStats) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *PeerStats) GetDownSeconds() uint64 { if m != nil { return m.DownSeconds } return 0 } type RegionHeartbeatRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` // Leader Peer sending the heartbeat. Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` // Leader considers that these peers are down. DownPeers []*PeerStats `protobuf:"bytes,4,rep,name=down_peers,json=downPeers" json:"down_peers,omitempty"` // Pending peers are the peers that the leader can't consider as // working followers. PendingPeers []*metapb.Peer `protobuf:"bytes,5,rep,name=pending_peers,json=pendingPeers" json:"pending_peers,omitempty"` // Bytes read/written during this period. BytesWritten uint64 `protobuf:"varint,6,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` BytesRead uint64 `protobuf:"varint,7,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` // Keys read/written during this period. KeysWritten uint64 `protobuf:"varint,8,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"` KeysRead uint64 `protobuf:"varint,9,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` // Approximate region size. ApproximateSize uint64 `protobuf:"varint,10,opt,name=approximate_size,json=approximateSize,proto3" json:"approximate_size,omitempty"` // Actually reported time interval Interval *TimeInterval `protobuf:"bytes,12,opt,name=interval" json:"interval,omitempty"` // Approximate number of keys. ApproximateKeys uint64 `protobuf:"varint,13,opt,name=approximate_keys,json=approximateKeys,proto3" json:"approximate_keys,omitempty"` // Term is the term of raft group. Term uint64 `protobuf:"varint,14,opt,name=term,proto3" json:"term,omitempty"` ReplicationStatus *replication_modepb.RegionReplicationStatus `protobuf:"bytes,15,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` // QueryStats reported write query stats, and there are read query stats in store heartbeat QueryStats *QueryStats `protobuf:"bytes,16,opt,name=query_stats,json=queryStats" json:"query_stats,omitempty"` // cpu_usage is the CPU time usage of the leader region since the last heartbeat, // which is calculated by cpu_time_delta/heartbeat_reported_interval. CpuUsage uint64 `protobuf:"varint,17,opt,name=cpu_usage,json=cpuUsage,proto3" json:"cpu_usage,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionHeartbeatRequest) Reset() { *m = RegionHeartbeatRequest{} } func (m *RegionHeartbeatRequest) String() string { return proto.CompactTextString(m) } func (*RegionHeartbeatRequest) ProtoMessage() {} func (*RegionHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{39} } func (m *RegionHeartbeatRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionHeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionHeartbeatRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionHeartbeatRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionHeartbeatRequest.Merge(dst, src) } func (m *RegionHeartbeatRequest) XXX_Size() int { return m.Size() } func (m *RegionHeartbeatRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionHeartbeatRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionHeartbeatRequest proto.InternalMessageInfo func (m *RegionHeartbeatRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *RegionHeartbeatRequest) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *RegionHeartbeatRequest) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } func (m *RegionHeartbeatRequest) GetDownPeers() []*PeerStats { if m != nil { return m.DownPeers } return nil } func (m *RegionHeartbeatRequest) GetPendingPeers() []*metapb.Peer { if m != nil { return m.PendingPeers } return nil } func (m *RegionHeartbeatRequest) GetBytesWritten() uint64 { if m != nil { return m.BytesWritten } return 0 } func (m *RegionHeartbeatRequest) GetBytesRead() uint64 { if m != nil { return m.BytesRead } return 0 } func (m *RegionHeartbeatRequest) GetKeysWritten() uint64 { if m != nil { return m.KeysWritten } return 0 } func (m *RegionHeartbeatRequest) GetKeysRead() uint64 { if m != nil { return m.KeysRead } return 0 } func (m *RegionHeartbeatRequest) GetApproximateSize() uint64 { if m != nil { return m.ApproximateSize } return 0 } func (m *RegionHeartbeatRequest) GetInterval() *TimeInterval { if m != nil { return m.Interval } return nil } func (m *RegionHeartbeatRequest) GetApproximateKeys() uint64 { if m != nil { return m.ApproximateKeys } return 0 } func (m *RegionHeartbeatRequest) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *RegionHeartbeatRequest) GetReplicationStatus() *replication_modepb.RegionReplicationStatus { if m != nil { return m.ReplicationStatus } return nil } func (m *RegionHeartbeatRequest) GetQueryStats() *QueryStats { if m != nil { return m.QueryStats } return nil } func (m *RegionHeartbeatRequest) GetCpuUsage() uint64 { if m != nil { return m.CpuUsage } return 0 } type ChangePeer struct { Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` ChangeType eraftpb.ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeer) Reset() { *m = ChangePeer{} } func (m *ChangePeer) String() string { return proto.CompactTextString(m) } func (*ChangePeer) ProtoMessage() {} func (*ChangePeer) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{40} } func (m *ChangePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeer.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeer) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeer.Merge(dst, src) } func (m *ChangePeer) XXX_Size() int { return m.Size() } func (m *ChangePeer) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeer.DiscardUnknown(m) } var xxx_messageInfo_ChangePeer proto.InternalMessageInfo func (m *ChangePeer) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *ChangePeer) GetChangeType() eraftpb.ConfChangeType { if m != nil { return m.ChangeType } return eraftpb.ConfChangeType_AddNode } type ChangePeerV2 struct { // If changes is empty, it means that to exit joint state. Changes []*ChangePeer `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeerV2) Reset() { *m = ChangePeerV2{} } func (m *ChangePeerV2) String() string { return proto.CompactTextString(m) } func (*ChangePeerV2) ProtoMessage() {} func (*ChangePeerV2) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{41} } func (m *ChangePeerV2) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeerV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeerV2.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeerV2) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeerV2.Merge(dst, src) } func (m *ChangePeerV2) XXX_Size() int { return m.Size() } func (m *ChangePeerV2) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeerV2.DiscardUnknown(m) } var xxx_messageInfo_ChangePeerV2 proto.InternalMessageInfo func (m *ChangePeerV2) GetChanges() []*ChangePeer { if m != nil { return m.Changes } return nil } type TransferLeader struct { Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` Peers []*metapb.Peer `protobuf:"bytes,2,rep,name=peers" json:"peers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TransferLeader) Reset() { *m = TransferLeader{} } func (m *TransferLeader) String() string { return proto.CompactTextString(m) } func (*TransferLeader) ProtoMessage() {} func (*TransferLeader) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{42} } func (m *TransferLeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TransferLeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TransferLeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TransferLeader) XXX_Merge(src proto.Message) { xxx_messageInfo_TransferLeader.Merge(dst, src) } func (m *TransferLeader) XXX_Size() int { return m.Size() } func (m *TransferLeader) XXX_DiscardUnknown() { xxx_messageInfo_TransferLeader.DiscardUnknown(m) } var xxx_messageInfo_TransferLeader proto.InternalMessageInfo func (m *TransferLeader) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *TransferLeader) GetPeers() []*metapb.Peer { if m != nil { return m.Peers } return nil } type Merge struct { Target *metapb.Region `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Merge) Reset() { *m = Merge{} } func (m *Merge) String() string { return proto.CompactTextString(m) } func (*Merge) ProtoMessage() {} func (*Merge) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{43} } func (m *Merge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Merge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Merge.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Merge) XXX_Merge(src proto.Message) { xxx_messageInfo_Merge.Merge(dst, src) } func (m *Merge) XXX_Size() int { return m.Size() } func (m *Merge) XXX_DiscardUnknown() { xxx_messageInfo_Merge.DiscardUnknown(m) } var xxx_messageInfo_Merge proto.InternalMessageInfo func (m *Merge) GetTarget() *metapb.Region { if m != nil { return m.Target } return nil } type SplitRegion struct { Policy CheckPolicy `protobuf:"varint,1,opt,name=policy,proto3,enum=pdpb.CheckPolicy" json:"policy,omitempty"` Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRegion) Reset() { *m = SplitRegion{} } func (m *SplitRegion) String() string { return proto.CompactTextString(m) } func (*SplitRegion) ProtoMessage() {} func (*SplitRegion) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{44} } func (m *SplitRegion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRegion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRegion.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRegion) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRegion.Merge(dst, src) } func (m *SplitRegion) XXX_Size() int { return m.Size() } func (m *SplitRegion) XXX_DiscardUnknown() { xxx_messageInfo_SplitRegion.DiscardUnknown(m) } var xxx_messageInfo_SplitRegion proto.InternalMessageInfo func (m *SplitRegion) GetPolicy() CheckPolicy { if m != nil { return m.Policy } return CheckPolicy_SCAN } func (m *SplitRegion) GetKeys() [][]byte { if m != nil { return m.Keys } return nil } type RegionHeartbeatResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // Notice, Pd only allows handling reported epoch >= current pd's. // Leader peer reports region status with RegionHeartbeatRequest // to pd regularly, pd will determine whether this region // should do ChangePeer or not. // E,g, max peer number is 3, region A, first only peer 1 in A. // 1. Pd region state -> Peers (1), ConfVer (1). // 2. Leader peer 1 reports region state to pd, pd finds the // peer number is < 3, so first changes its current region // state -> Peers (1, 2), ConfVer (1), and returns ChangePeer Adding 2. // 3. Leader does ChangePeer, then reports Peers (1, 2), ConfVer (2), // pd updates its state -> Peers (1, 2), ConfVer (2). // 4. Leader may report old Peers (1), ConfVer (1) to pd before ConfChange // finished, pd stills responses ChangePeer Adding 2, of course, we must // guarantee the second ChangePeer can't be applied in TiKV. ChangePeer *ChangePeer `protobuf:"bytes,2,opt,name=change_peer,json=changePeer" json:"change_peer,omitempty"` // Pd can return transfer_leader to let TiKV does leader transfer itself. TransferLeader *TransferLeader `protobuf:"bytes,3,opt,name=transfer_leader,json=transferLeader" json:"transfer_leader,omitempty"` // ID of the region RegionId uint64 `protobuf:"varint,4,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,5,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` // Leader of the region at the moment of the corresponding request was made. TargetPeer *metapb.Peer `protobuf:"bytes,6,opt,name=target_peer,json=targetPeer" json:"target_peer,omitempty"` Merge *Merge `protobuf:"bytes,7,opt,name=merge" json:"merge,omitempty"` // PD sends split_region to let TiKV split a region into two regions. SplitRegion *SplitRegion `protobuf:"bytes,8,opt,name=split_region,json=splitRegion" json:"split_region,omitempty"` // Multiple change peer operations atomically. // Note: PD can use both ChangePeer and ChangePeerV2 at the same time // (not in the same RegionHeartbeatResponse). // Now, PD use ChangePeerV2 in following scenarios: // 1. replacing peers // 2. demoting voter directly ChangePeerV2 *ChangePeerV2 `protobuf:"bytes,9,opt,name=change_peer_v2,json=changePeerV2" json:"change_peer_v2,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionHeartbeatResponse) Reset() { *m = RegionHeartbeatResponse{} } func (m *RegionHeartbeatResponse) String() string { return proto.CompactTextString(m) } func (*RegionHeartbeatResponse) ProtoMessage() {} func (*RegionHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{45} } func (m *RegionHeartbeatResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionHeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionHeartbeatResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionHeartbeatResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionHeartbeatResponse.Merge(dst, src) } func (m *RegionHeartbeatResponse) XXX_Size() int { return m.Size() } func (m *RegionHeartbeatResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionHeartbeatResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionHeartbeatResponse proto.InternalMessageInfo func (m *RegionHeartbeatResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *RegionHeartbeatResponse) GetChangePeer() *ChangePeer { if m != nil { return m.ChangePeer } return nil } func (m *RegionHeartbeatResponse) GetTransferLeader() *TransferLeader { if m != nil { return m.TransferLeader } return nil } func (m *RegionHeartbeatResponse) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RegionHeartbeatResponse) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *RegionHeartbeatResponse) GetTargetPeer() *metapb.Peer { if m != nil { return m.TargetPeer } return nil } func (m *RegionHeartbeatResponse) GetMerge() *Merge { if m != nil { return m.Merge } return nil } func (m *RegionHeartbeatResponse) GetSplitRegion() *SplitRegion { if m != nil { return m.SplitRegion } return nil } func (m *RegionHeartbeatResponse) GetChangePeerV2() *ChangePeerV2 { if m != nil { return m.ChangePeerV2 } return nil } type AskSplitRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AskSplitRequest) Reset() { *m = AskSplitRequest{} } func (m *AskSplitRequest) String() string { return proto.CompactTextString(m) } func (*AskSplitRequest) ProtoMessage() {} func (*AskSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{46} } func (m *AskSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AskSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AskSplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AskSplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AskSplitRequest.Merge(dst, src) } func (m *AskSplitRequest) XXX_Size() int { return m.Size() } func (m *AskSplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_AskSplitRequest.DiscardUnknown(m) } var xxx_messageInfo_AskSplitRequest proto.InternalMessageInfo func (m *AskSplitRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *AskSplitRequest) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } type AskSplitResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // We split the region into two, first uses the origin // parent region id, and the second uses the new_region_id. // We must guarantee that the new_region_id is global unique. NewRegionId uint64 `protobuf:"varint,2,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` // The peer ids for the new split region. NewPeerIds []uint64 `protobuf:"varint,3,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AskSplitResponse) Reset() { *m = AskSplitResponse{} } func (m *AskSplitResponse) String() string { return proto.CompactTextString(m) } func (*AskSplitResponse) ProtoMessage() {} func (*AskSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{47} } func (m *AskSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AskSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AskSplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AskSplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_AskSplitResponse.Merge(dst, src) } func (m *AskSplitResponse) XXX_Size() int { return m.Size() } func (m *AskSplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_AskSplitResponse.DiscardUnknown(m) } var xxx_messageInfo_AskSplitResponse proto.InternalMessageInfo func (m *AskSplitResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *AskSplitResponse) GetNewRegionId() uint64 { if m != nil { return m.NewRegionId } return 0 } func (m *AskSplitResponse) GetNewPeerIds() []uint64 { if m != nil { return m.NewPeerIds } return nil } type ReportSplitRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportSplitRequest) Reset() { *m = ReportSplitRequest{} } func (m *ReportSplitRequest) String() string { return proto.CompactTextString(m) } func (*ReportSplitRequest) ProtoMessage() {} func (*ReportSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{48} } func (m *ReportSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportSplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportSplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportSplitRequest.Merge(dst, src) } func (m *ReportSplitRequest) XXX_Size() int { return m.Size() } func (m *ReportSplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReportSplitRequest.DiscardUnknown(m) } var xxx_messageInfo_ReportSplitRequest proto.InternalMessageInfo func (m *ReportSplitRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *ReportSplitRequest) GetLeft() *metapb.Region { if m != nil { return m.Left } return nil } func (m *ReportSplitRequest) GetRight() *metapb.Region { if m != nil { return m.Right } return nil } type ReportSplitResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportSplitResponse) Reset() { *m = ReportSplitResponse{} } func (m *ReportSplitResponse) String() string { return proto.CompactTextString(m) } func (*ReportSplitResponse) ProtoMessage() {} func (*ReportSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{49} } func (m *ReportSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportSplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportSplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportSplitResponse.Merge(dst, src) } func (m *ReportSplitResponse) XXX_Size() int { return m.Size() } func (m *ReportSplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReportSplitResponse.DiscardUnknown(m) } var xxx_messageInfo_ReportSplitResponse proto.InternalMessageInfo func (m *ReportSplitResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } type AskBatchSplitRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` SplitCount uint32 `protobuf:"varint,3,opt,name=split_count,json=splitCount,proto3" json:"split_count,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AskBatchSplitRequest) Reset() { *m = AskBatchSplitRequest{} } func (m *AskBatchSplitRequest) String() string { return proto.CompactTextString(m) } func (*AskBatchSplitRequest) ProtoMessage() {} func (*AskBatchSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{50} } func (m *AskBatchSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AskBatchSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AskBatchSplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AskBatchSplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AskBatchSplitRequest.Merge(dst, src) } func (m *AskBatchSplitRequest) XXX_Size() int { return m.Size() } func (m *AskBatchSplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_AskBatchSplitRequest.DiscardUnknown(m) } var xxx_messageInfo_AskBatchSplitRequest proto.InternalMessageInfo func (m *AskBatchSplitRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *AskBatchSplitRequest) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *AskBatchSplitRequest) GetSplitCount() uint32 { if m != nil { return m.SplitCount } return 0 } type SplitID struct { NewRegionId uint64 `protobuf:"varint,1,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` NewPeerIds []uint64 `protobuf:"varint,2,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitID) Reset() { *m = SplitID{} } func (m *SplitID) String() string { return proto.CompactTextString(m) } func (*SplitID) ProtoMessage() {} func (*SplitID) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{51} } func (m *SplitID) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitID.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitID) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitID.Merge(dst, src) } func (m *SplitID) XXX_Size() int { return m.Size() } func (m *SplitID) XXX_DiscardUnknown() { xxx_messageInfo_SplitID.DiscardUnknown(m) } var xxx_messageInfo_SplitID proto.InternalMessageInfo func (m *SplitID) GetNewRegionId() uint64 { if m != nil { return m.NewRegionId } return 0 } func (m *SplitID) GetNewPeerIds() []uint64 { if m != nil { return m.NewPeerIds } return nil } type AskBatchSplitResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Ids []*SplitID `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AskBatchSplitResponse) Reset() { *m = AskBatchSplitResponse{} } func (m *AskBatchSplitResponse) String() string { return proto.CompactTextString(m) } func (*AskBatchSplitResponse) ProtoMessage() {} func (*AskBatchSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{52} } func (m *AskBatchSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AskBatchSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AskBatchSplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AskBatchSplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_AskBatchSplitResponse.Merge(dst, src) } func (m *AskBatchSplitResponse) XXX_Size() int { return m.Size() } func (m *AskBatchSplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_AskBatchSplitResponse.DiscardUnknown(m) } var xxx_messageInfo_AskBatchSplitResponse proto.InternalMessageInfo func (m *AskBatchSplitResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *AskBatchSplitResponse) GetIds() []*SplitID { if m != nil { return m.Ids } return nil } type ReportBatchSplitRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportBatchSplitRequest) Reset() { *m = ReportBatchSplitRequest{} } func (m *ReportBatchSplitRequest) String() string { return proto.CompactTextString(m) } func (*ReportBatchSplitRequest) ProtoMessage() {} func (*ReportBatchSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{53} } func (m *ReportBatchSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportBatchSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportBatchSplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportBatchSplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportBatchSplitRequest.Merge(dst, src) } func (m *ReportBatchSplitRequest) XXX_Size() int { return m.Size() } func (m *ReportBatchSplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReportBatchSplitRequest.DiscardUnknown(m) } var xxx_messageInfo_ReportBatchSplitRequest proto.InternalMessageInfo func (m *ReportBatchSplitRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *ReportBatchSplitRequest) GetRegions() []*metapb.Region { if m != nil { return m.Regions } return nil } type ReportBatchSplitResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportBatchSplitResponse) Reset() { *m = ReportBatchSplitResponse{} } func (m *ReportBatchSplitResponse) String() string { return proto.CompactTextString(m) } func (*ReportBatchSplitResponse) ProtoMessage() {} func (*ReportBatchSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{54} } func (m *ReportBatchSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportBatchSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportBatchSplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportBatchSplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportBatchSplitResponse.Merge(dst, src) } func (m *ReportBatchSplitResponse) XXX_Size() int { return m.Size() } func (m *ReportBatchSplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReportBatchSplitResponse.DiscardUnknown(m) } var xxx_messageInfo_ReportBatchSplitResponse proto.InternalMessageInfo func (m *ReportBatchSplitResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } type TimeInterval struct { // The unix timestamp in seconds of the start of this period. StartTimestamp uint64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"` // The unix timestamp in seconds of the end of this period. EndTimestamp uint64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TimeInterval) Reset() { *m = TimeInterval{} } func (m *TimeInterval) String() string { return proto.CompactTextString(m) } func (*TimeInterval) ProtoMessage() {} func (*TimeInterval) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{55} } func (m *TimeInterval) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TimeInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TimeInterval.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TimeInterval) XXX_Merge(src proto.Message) { xxx_messageInfo_TimeInterval.Merge(dst, src) } func (m *TimeInterval) XXX_Size() int { return m.Size() } func (m *TimeInterval) XXX_DiscardUnknown() { xxx_messageInfo_TimeInterval.DiscardUnknown(m) } var xxx_messageInfo_TimeInterval proto.InternalMessageInfo func (m *TimeInterval) GetStartTimestamp() uint64 { if m != nil { return m.StartTimestamp } return 0 } func (m *TimeInterval) GetEndTimestamp() uint64 { if m != nil { return m.EndTimestamp } return 0 } type RecordPair struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value uint64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RecordPair) Reset() { *m = RecordPair{} } func (m *RecordPair) String() string { return proto.CompactTextString(m) } func (*RecordPair) ProtoMessage() {} func (*RecordPair) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{56} } func (m *RecordPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RecordPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RecordPair.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RecordPair) XXX_Merge(src proto.Message) { xxx_messageInfo_RecordPair.Merge(dst, src) } func (m *RecordPair) XXX_Size() int { return m.Size() } func (m *RecordPair) XXX_DiscardUnknown() { xxx_messageInfo_RecordPair.DiscardUnknown(m) } var xxx_messageInfo_RecordPair proto.InternalMessageInfo func (m *RecordPair) GetKey() string { if m != nil { return m.Key } return "" } func (m *RecordPair) GetValue() uint64 { if m != nil { return m.Value } return 0 } type PeerStat struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` ReadKeys uint64 `protobuf:"varint,2,opt,name=read_keys,json=readKeys,proto3" json:"read_keys,omitempty"` ReadBytes uint64 `protobuf:"varint,3,opt,name=read_bytes,json=readBytes,proto3" json:"read_bytes,omitempty"` QueryStats *QueryStats `protobuf:"bytes,4,opt,name=query_stats,json=queryStats" json:"query_stats,omitempty"` WrittenKeys uint64 `protobuf:"varint,5,opt,name=written_keys,json=writtenKeys,proto3" json:"written_keys,omitempty"` WrittenBytes uint64 `protobuf:"varint,6,opt,name=written_bytes,json=writtenBytes,proto3" json:"written_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PeerStat) Reset() { *m = PeerStat{} } func (m *PeerStat) String() string { return proto.CompactTextString(m) } func (*PeerStat) ProtoMessage() {} func (*PeerStat) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{57} } func (m *PeerStat) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PeerStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PeerStat.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PeerStat) XXX_Merge(src proto.Message) { xxx_messageInfo_PeerStat.Merge(dst, src) } func (m *PeerStat) XXX_Size() int { return m.Size() } func (m *PeerStat) XXX_DiscardUnknown() { xxx_messageInfo_PeerStat.DiscardUnknown(m) } var xxx_messageInfo_PeerStat proto.InternalMessageInfo func (m *PeerStat) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *PeerStat) GetReadKeys() uint64 { if m != nil { return m.ReadKeys } return 0 } func (m *PeerStat) GetReadBytes() uint64 { if m != nil { return m.ReadBytes } return 0 } func (m *PeerStat) GetQueryStats() *QueryStats { if m != nil { return m.QueryStats } return nil } func (m *PeerStat) GetWrittenKeys() uint64 { if m != nil { return m.WrittenKeys } return 0 } func (m *PeerStat) GetWrittenBytes() uint64 { if m != nil { return m.WrittenBytes } return 0 } type StoreStats struct { StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` // Capacity for the store. Capacity uint64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"` // Available size for the store. Available uint64 `protobuf:"varint,3,opt,name=available,proto3" json:"available,omitempty"` // Total region count in this store. RegionCount uint32 `protobuf:"varint,4,opt,name=region_count,json=regionCount,proto3" json:"region_count,omitempty"` // Current sending snapshot count. SendingSnapCount uint32 `protobuf:"varint,5,opt,name=sending_snap_count,json=sendingSnapCount,proto3" json:"sending_snap_count,omitempty"` // Current receiving snapshot count. ReceivingSnapCount uint32 `protobuf:"varint,6,opt,name=receiving_snap_count,json=receivingSnapCount,proto3" json:"receiving_snap_count,omitempty"` // When the store is started (unix timestamp in seconds). StartTime uint32 `protobuf:"varint,7,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` // How many region is applying snapshot. ApplyingSnapCount uint32 `protobuf:"varint,8,opt,name=applying_snap_count,json=applyingSnapCount,proto3" json:"applying_snap_count,omitempty"` // If the store is busy IsBusy bool `protobuf:"varint,9,opt,name=is_busy,json=isBusy,proto3" json:"is_busy,omitempty"` // Actually used space by db UsedSize uint64 `protobuf:"varint,10,opt,name=used_size,json=usedSize,proto3" json:"used_size,omitempty"` // Bytes written for the store during this period. BytesWritten uint64 `protobuf:"varint,11,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` // Keys written for the store during this period. KeysWritten uint64 `protobuf:"varint,12,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"` // Bytes read for the store during this period. BytesRead uint64 `protobuf:"varint,13,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` // Keys read for the store during this period. KeysRead uint64 `protobuf:"varint,14,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` // Actually reported time interval Interval *TimeInterval `protobuf:"bytes,15,opt,name=interval" json:"interval,omitempty"` // Threads' CPU usages in the store CpuUsages []*RecordPair `protobuf:"bytes,16,rep,name=cpu_usages,json=cpuUsages" json:"cpu_usages,omitempty"` // Threads' read disk I/O rates in the store ReadIoRates []*RecordPair `protobuf:"bytes,17,rep,name=read_io_rates,json=readIoRates" json:"read_io_rates,omitempty"` // Threads' write disk I/O rates in the store WriteIoRates []*RecordPair `protobuf:"bytes,18,rep,name=write_io_rates,json=writeIoRates" json:"write_io_rates,omitempty"` // Operations' latencies in the store OpLatencies []*RecordPair `protobuf:"bytes,19,rep,name=op_latencies,json=opLatencies" json:"op_latencies,omitempty"` // Hot peer stat in the store PeerStats []*PeerStat `protobuf:"bytes,20,rep,name=peer_stats,json=peerStats" json:"peer_stats,omitempty"` // Store query stats QueryStats *QueryStats `protobuf:"bytes,21,opt,name=query_stats,json=queryStats" json:"query_stats,omitempty"` // Score that represents the speed of the store, ranges in [1, 100], lower is better. SlowScore uint64 `protobuf:"varint,22,opt,name=slow_score,json=slowScore,proto3" json:"slow_score,omitempty"` // Damaged regions on the store that need to be removed by PD. DamagedRegionsId []uint64 `protobuf:"varint,23,rep,packed,name=damaged_regions_id,json=damagedRegionsId" json:"damaged_regions_id,omitempty"` // If the apply worker is busy, namely high apply wait duration IsApplyBusy bool `protobuf:"varint,24,opt,name=is_apply_busy,json=isApplyBusy,proto3" json:"is_apply_busy,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreStats) Reset() { *m = StoreStats{} } func (m *StoreStats) String() string { return proto.CompactTextString(m) } func (*StoreStats) ProtoMessage() {} func (*StoreStats) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{58} } func (m *StoreStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreStats.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreStats) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreStats.Merge(dst, src) } func (m *StoreStats) XXX_Size() int { return m.Size() } func (m *StoreStats) XXX_DiscardUnknown() { xxx_messageInfo_StoreStats.DiscardUnknown(m) } var xxx_messageInfo_StoreStats proto.InternalMessageInfo func (m *StoreStats) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } func (m *StoreStats) GetCapacity() uint64 { if m != nil { return m.Capacity } return 0 } func (m *StoreStats) GetAvailable() uint64 { if m != nil { return m.Available } return 0 } func (m *StoreStats) GetRegionCount() uint32 { if m != nil { return m.RegionCount } return 0 } func (m *StoreStats) GetSendingSnapCount() uint32 { if m != nil { return m.SendingSnapCount } return 0 } func (m *StoreStats) GetReceivingSnapCount() uint32 { if m != nil { return m.ReceivingSnapCount } return 0 } func (m *StoreStats) GetStartTime() uint32 { if m != nil { return m.StartTime } return 0 } func (m *StoreStats) GetApplyingSnapCount() uint32 { if m != nil { return m.ApplyingSnapCount } return 0 } func (m *StoreStats) GetIsBusy() bool { if m != nil { return m.IsBusy } return false } func (m *StoreStats) GetUsedSize() uint64 { if m != nil { return m.UsedSize } return 0 } func (m *StoreStats) GetBytesWritten() uint64 { if m != nil { return m.BytesWritten } return 0 } func (m *StoreStats) GetKeysWritten() uint64 { if m != nil { return m.KeysWritten } return 0 } func (m *StoreStats) GetBytesRead() uint64 { if m != nil { return m.BytesRead } return 0 } func (m *StoreStats) GetKeysRead() uint64 { if m != nil { return m.KeysRead } return 0 } func (m *StoreStats) GetInterval() *TimeInterval { if m != nil { return m.Interval } return nil } func (m *StoreStats) GetCpuUsages() []*RecordPair { if m != nil { return m.CpuUsages } return nil } func (m *StoreStats) GetReadIoRates() []*RecordPair { if m != nil { return m.ReadIoRates } return nil } func (m *StoreStats) GetWriteIoRates() []*RecordPair { if m != nil { return m.WriteIoRates } return nil } func (m *StoreStats) GetOpLatencies() []*RecordPair { if m != nil { return m.OpLatencies } return nil } func (m *StoreStats) GetPeerStats() []*PeerStat { if m != nil { return m.PeerStats } return nil } func (m *StoreStats) GetQueryStats() *QueryStats { if m != nil { return m.QueryStats } return nil } func (m *StoreStats) GetSlowScore() uint64 { if m != nil { return m.SlowScore } return 0 } func (m *StoreStats) GetDamagedRegionsId() []uint64 { if m != nil { return m.DamagedRegionsId } return nil } func (m *StoreStats) GetIsApplyBusy() bool { if m != nil { return m.IsApplyBusy } return false } type PeerReport struct { RaftState *raft_serverpb.RaftLocalState `protobuf:"bytes,1,opt,name=raft_state,json=raftState" json:"raft_state,omitempty"` RegionState *raft_serverpb.RegionLocalState `protobuf:"bytes,2,opt,name=region_state,json=regionState" json:"region_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PeerReport) Reset() { *m = PeerReport{} } func (m *PeerReport) String() string { return proto.CompactTextString(m) } func (*PeerReport) ProtoMessage() {} func (*PeerReport) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{59} } func (m *PeerReport) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PeerReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PeerReport.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PeerReport) XXX_Merge(src proto.Message) { xxx_messageInfo_PeerReport.Merge(dst, src) } func (m *PeerReport) XXX_Size() int { return m.Size() } func (m *PeerReport) XXX_DiscardUnknown() { xxx_messageInfo_PeerReport.DiscardUnknown(m) } var xxx_messageInfo_PeerReport proto.InternalMessageInfo func (m *PeerReport) GetRaftState() *raft_serverpb.RaftLocalState { if m != nil { return m.RaftState } return nil } func (m *PeerReport) GetRegionState() *raft_serverpb.RegionLocalState { if m != nil { return m.RegionState } return nil } type StoreReport struct { PeerReports []*PeerReport `protobuf:"bytes,1,rep,name=peer_reports,json=peerReports" json:"peer_reports,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreReport) Reset() { *m = StoreReport{} } func (m *StoreReport) String() string { return proto.CompactTextString(m) } func (*StoreReport) ProtoMessage() {} func (*StoreReport) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{60} } func (m *StoreReport) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreReport.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreReport) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreReport.Merge(dst, src) } func (m *StoreReport) XXX_Size() int { return m.Size() } func (m *StoreReport) XXX_DiscardUnknown() { xxx_messageInfo_StoreReport.DiscardUnknown(m) } var xxx_messageInfo_StoreReport proto.InternalMessageInfo func (m *StoreReport) GetPeerReports() []*PeerReport { if m != nil { return m.PeerReports } return nil } type StoreHeartbeatRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Stats *StoreStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"` // Detailed store report that is only filled up on PD's demand for online unsafe recover. StoreReport *StoreReport `protobuf:"bytes,3,opt,name=store_report,json=storeReport" json:"store_report,omitempty"` DrAutosyncStatus *replication_modepb.StoreDRAutoSyncStatus `protobuf:"bytes,4,opt,name=dr_autosync_status,json=drAutosyncStatus" json:"dr_autosync_status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreHeartbeatRequest) Reset() { *m = StoreHeartbeatRequest{} } func (m *StoreHeartbeatRequest) String() string { return proto.CompactTextString(m) } func (*StoreHeartbeatRequest) ProtoMessage() {} func (*StoreHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{61} } func (m *StoreHeartbeatRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreHeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreHeartbeatRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreHeartbeatRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreHeartbeatRequest.Merge(dst, src) } func (m *StoreHeartbeatRequest) XXX_Size() int { return m.Size() } func (m *StoreHeartbeatRequest) XXX_DiscardUnknown() { xxx_messageInfo_StoreHeartbeatRequest.DiscardUnknown(m) } var xxx_messageInfo_StoreHeartbeatRequest proto.InternalMessageInfo func (m *StoreHeartbeatRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *StoreHeartbeatRequest) GetStats() *StoreStats { if m != nil { return m.Stats } return nil } func (m *StoreHeartbeatRequest) GetStoreReport() *StoreReport { if m != nil { return m.StoreReport } return nil } func (m *StoreHeartbeatRequest) GetDrAutosyncStatus() *replication_modepb.StoreDRAutoSyncStatus { if m != nil { return m.DrAutosyncStatus } return nil } type RecoveryPlan struct { Creates []*metapb.Region `protobuf:"bytes,1,rep,name=creates" json:"creates,omitempty"` Updates []*metapb.Region `protobuf:"bytes,2,rep,name=updates" json:"updates,omitempty"` Deletes []uint64 `protobuf:"varint,3,rep,packed,name=deletes" json:"deletes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RecoveryPlan) Reset() { *m = RecoveryPlan{} } func (m *RecoveryPlan) String() string { return proto.CompactTextString(m) } func (*RecoveryPlan) ProtoMessage() {} func (*RecoveryPlan) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{62} } func (m *RecoveryPlan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RecoveryPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RecoveryPlan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RecoveryPlan) XXX_Merge(src proto.Message) { xxx_messageInfo_RecoveryPlan.Merge(dst, src) } func (m *RecoveryPlan) XXX_Size() int { return m.Size() } func (m *RecoveryPlan) XXX_DiscardUnknown() { xxx_messageInfo_RecoveryPlan.DiscardUnknown(m) } var xxx_messageInfo_RecoveryPlan proto.InternalMessageInfo func (m *RecoveryPlan) GetCreates() []*metapb.Region { if m != nil { return m.Creates } return nil } func (m *RecoveryPlan) GetUpdates() []*metapb.Region { if m != nil { return m.Updates } return nil } func (m *RecoveryPlan) GetDeletes() []uint64 { if m != nil { return m.Deletes } return nil } type StoreHeartbeatResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` ClusterVersion string `protobuf:"bytes,3,opt,name=cluster_version,json=clusterVersion,proto3" json:"cluster_version,omitempty"` RequireDetailedReport bool `protobuf:"varint,4,opt,name=require_detailed_report,json=requireDetailedReport,proto3" json:"require_detailed_report,omitempty"` Plan *RecoveryPlan `protobuf:"bytes,5,opt,name=plan" json:"plan,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreHeartbeatResponse) Reset() { *m = StoreHeartbeatResponse{} } func (m *StoreHeartbeatResponse) String() string { return proto.CompactTextString(m) } func (*StoreHeartbeatResponse) ProtoMessage() {} func (*StoreHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{63} } func (m *StoreHeartbeatResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreHeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreHeartbeatResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreHeartbeatResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreHeartbeatResponse.Merge(dst, src) } func (m *StoreHeartbeatResponse) XXX_Size() int { return m.Size() } func (m *StoreHeartbeatResponse) XXX_DiscardUnknown() { xxx_messageInfo_StoreHeartbeatResponse.DiscardUnknown(m) } var xxx_messageInfo_StoreHeartbeatResponse proto.InternalMessageInfo func (m *StoreHeartbeatResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *StoreHeartbeatResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { return m.ReplicationStatus } return nil } func (m *StoreHeartbeatResponse) GetClusterVersion() string { if m != nil { return m.ClusterVersion } return "" } func (m *StoreHeartbeatResponse) GetRequireDetailedReport() bool { if m != nil { return m.RequireDetailedReport } return false } func (m *StoreHeartbeatResponse) GetPlan() *RecoveryPlan { if m != nil { return m.Plan } return nil } type ScatterRegionRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // Deprecated: Do not use. // PD will use these region information if it can't find the region. // For example, the region is just split and hasn't report to PD yet. Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` Leader *metapb.Peer `protobuf:"bytes,4,opt,name=leader" json:"leader,omitempty"` // If group is defined, the regions with the same group would be scattered as a whole group. // If not defined, the regions would be scattered in a cluster level. Group string `protobuf:"bytes,5,opt,name=group,proto3" json:"group,omitempty"` // If regions_id is defined, the region_id would be ignored. RegionsId []uint64 `protobuf:"varint,6,rep,packed,name=regions_id,json=regionsId" json:"regions_id,omitempty"` RetryLimit uint64 `protobuf:"varint,7,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScatterRegionRequest) Reset() { *m = ScatterRegionRequest{} } func (m *ScatterRegionRequest) String() string { return proto.CompactTextString(m) } func (*ScatterRegionRequest) ProtoMessage() {} func (*ScatterRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{64} } func (m *ScatterRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScatterRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScatterRegionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScatterRegionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ScatterRegionRequest.Merge(dst, src) } func (m *ScatterRegionRequest) XXX_Size() int { return m.Size() } func (m *ScatterRegionRequest) XXX_DiscardUnknown() { xxx_messageInfo_ScatterRegionRequest.DiscardUnknown(m) } var xxx_messageInfo_ScatterRegionRequest proto.InternalMessageInfo func (m *ScatterRegionRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } // Deprecated: Do not use. func (m *ScatterRegionRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *ScatterRegionRequest) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *ScatterRegionRequest) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } func (m *ScatterRegionRequest) GetGroup() string { if m != nil { return m.Group } return "" } func (m *ScatterRegionRequest) GetRegionsId() []uint64 { if m != nil { return m.RegionsId } return nil } func (m *ScatterRegionRequest) GetRetryLimit() uint64 { if m != nil { return m.RetryLimit } return 0 } type ScatterRegionResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` FinishedPercentage uint64 `protobuf:"varint,2,opt,name=finished_percentage,json=finishedPercentage,proto3" json:"finished_percentage,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ScatterRegionResponse) Reset() { *m = ScatterRegionResponse{} } func (m *ScatterRegionResponse) String() string { return proto.CompactTextString(m) } func (*ScatterRegionResponse) ProtoMessage() {} func (*ScatterRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{65} } func (m *ScatterRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ScatterRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ScatterRegionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ScatterRegionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ScatterRegionResponse.Merge(dst, src) } func (m *ScatterRegionResponse) XXX_Size() int { return m.Size() } func (m *ScatterRegionResponse) XXX_DiscardUnknown() { xxx_messageInfo_ScatterRegionResponse.DiscardUnknown(m) } var xxx_messageInfo_ScatterRegionResponse proto.InternalMessageInfo func (m *ScatterRegionResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *ScatterRegionResponse) GetFinishedPercentage() uint64 { if m != nil { return m.FinishedPercentage } return 0 } type GetGCSafePointRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetGCSafePointRequest) Reset() { *m = GetGCSafePointRequest{} } func (m *GetGCSafePointRequest) String() string { return proto.CompactTextString(m) } func (*GetGCSafePointRequest) ProtoMessage() {} func (*GetGCSafePointRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{66} } func (m *GetGCSafePointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetGCSafePointRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetGCSafePointRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetGCSafePointRequest.Merge(dst, src) } func (m *GetGCSafePointRequest) XXX_Size() int { return m.Size() } func (m *GetGCSafePointRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetGCSafePointRequest.DiscardUnknown(m) } var xxx_messageInfo_GetGCSafePointRequest proto.InternalMessageInfo func (m *GetGCSafePointRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } type GetGCSafePointResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetGCSafePointResponse) Reset() { *m = GetGCSafePointResponse{} } func (m *GetGCSafePointResponse) String() string { return proto.CompactTextString(m) } func (*GetGCSafePointResponse) ProtoMessage() {} func (*GetGCSafePointResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{67} } func (m *GetGCSafePointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetGCSafePointResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetGCSafePointResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetGCSafePointResponse.Merge(dst, src) } func (m *GetGCSafePointResponse) XXX_Size() int { return m.Size() } func (m *GetGCSafePointResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetGCSafePointResponse.DiscardUnknown(m) } var xxx_messageInfo_GetGCSafePointResponse proto.InternalMessageInfo func (m *GetGCSafePointResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetGCSafePointResponse) GetSafePoint() uint64 { if m != nil { return m.SafePoint } return 0 } type UpdateGCSafePointRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateGCSafePointRequest) Reset() { *m = UpdateGCSafePointRequest{} } func (m *UpdateGCSafePointRequest) String() string { return proto.CompactTextString(m) } func (*UpdateGCSafePointRequest) ProtoMessage() {} func (*UpdateGCSafePointRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{68} } func (m *UpdateGCSafePointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateGCSafePointRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateGCSafePointRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateGCSafePointRequest.Merge(dst, src) } func (m *UpdateGCSafePointRequest) XXX_Size() int { return m.Size() } func (m *UpdateGCSafePointRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateGCSafePointRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateGCSafePointRequest proto.InternalMessageInfo func (m *UpdateGCSafePointRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *UpdateGCSafePointRequest) GetSafePoint() uint64 { if m != nil { return m.SafePoint } return 0 } type UpdateGCSafePointResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` NewSafePoint uint64 `protobuf:"varint,2,opt,name=new_safe_point,json=newSafePoint,proto3" json:"new_safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateGCSafePointResponse) Reset() { *m = UpdateGCSafePointResponse{} } func (m *UpdateGCSafePointResponse) String() string { return proto.CompactTextString(m) } func (*UpdateGCSafePointResponse) ProtoMessage() {} func (*UpdateGCSafePointResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{69} } func (m *UpdateGCSafePointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateGCSafePointResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateGCSafePointResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateGCSafePointResponse.Merge(dst, src) } func (m *UpdateGCSafePointResponse) XXX_Size() int { return m.Size() } func (m *UpdateGCSafePointResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateGCSafePointResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateGCSafePointResponse proto.InternalMessageInfo func (m *UpdateGCSafePointResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *UpdateGCSafePointResponse) GetNewSafePoint() uint64 { if m != nil { return m.NewSafePoint } return 0 } type UpdateServiceGCSafePointRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ServiceId []byte `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"` SafePoint uint64 `protobuf:"varint,4,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateServiceGCSafePointRequest) Reset() { *m = UpdateServiceGCSafePointRequest{} } func (m *UpdateServiceGCSafePointRequest) String() string { return proto.CompactTextString(m) } func (*UpdateServiceGCSafePointRequest) ProtoMessage() {} func (*UpdateServiceGCSafePointRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{70} } func (m *UpdateServiceGCSafePointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateServiceGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateServiceGCSafePointRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateServiceGCSafePointRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateServiceGCSafePointRequest.Merge(dst, src) } func (m *UpdateServiceGCSafePointRequest) XXX_Size() int { return m.Size() } func (m *UpdateServiceGCSafePointRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateServiceGCSafePointRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateServiceGCSafePointRequest proto.InternalMessageInfo func (m *UpdateServiceGCSafePointRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *UpdateServiceGCSafePointRequest) GetServiceId() []byte { if m != nil { return m.ServiceId } return nil } func (m *UpdateServiceGCSafePointRequest) GetTTL() int64 { if m != nil { return m.TTL } return 0 } func (m *UpdateServiceGCSafePointRequest) GetSafePoint() uint64 { if m != nil { return m.SafePoint } return 0 } type UpdateServiceGCSafePointResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` ServiceId []byte `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"` MinSafePoint uint64 `protobuf:"varint,4,opt,name=min_safe_point,json=minSafePoint,proto3" json:"min_safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateServiceGCSafePointResponse) Reset() { *m = UpdateServiceGCSafePointResponse{} } func (m *UpdateServiceGCSafePointResponse) String() string { return proto.CompactTextString(m) } func (*UpdateServiceGCSafePointResponse) ProtoMessage() {} func (*UpdateServiceGCSafePointResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{71} } func (m *UpdateServiceGCSafePointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateServiceGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateServiceGCSafePointResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *UpdateServiceGCSafePointResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateServiceGCSafePointResponse.Merge(dst, src) } func (m *UpdateServiceGCSafePointResponse) XXX_Size() int { return m.Size() } func (m *UpdateServiceGCSafePointResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateServiceGCSafePointResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateServiceGCSafePointResponse proto.InternalMessageInfo func (m *UpdateServiceGCSafePointResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *UpdateServiceGCSafePointResponse) GetServiceId() []byte { if m != nil { return m.ServiceId } return nil } func (m *UpdateServiceGCSafePointResponse) GetTTL() int64 { if m != nil { return m.TTL } return 0 } func (m *UpdateServiceGCSafePointResponse) GetMinSafePoint() uint64 { if m != nil { return m.MinSafePoint } return 0 } type RegionStat struct { // Bytes read/written during this period. BytesWritten uint64 `protobuf:"varint,1,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` BytesRead uint64 `protobuf:"varint,2,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` // Keys read/written during this period. KeysWritten uint64 `protobuf:"varint,3,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"` KeysRead uint64 `protobuf:"varint,4,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionStat) Reset() { *m = RegionStat{} } func (m *RegionStat) String() string { return proto.CompactTextString(m) } func (*RegionStat) ProtoMessage() {} func (*RegionStat) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{72} } func (m *RegionStat) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionStat.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionStat) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionStat.Merge(dst, src) } func (m *RegionStat) XXX_Size() int { return m.Size() } func (m *RegionStat) XXX_DiscardUnknown() { xxx_messageInfo_RegionStat.DiscardUnknown(m) } var xxx_messageInfo_RegionStat proto.InternalMessageInfo func (m *RegionStat) GetBytesWritten() uint64 { if m != nil { return m.BytesWritten } return 0 } func (m *RegionStat) GetBytesRead() uint64 { if m != nil { return m.BytesRead } return 0 } func (m *RegionStat) GetKeysWritten() uint64 { if m != nil { return m.KeysWritten } return 0 } func (m *RegionStat) GetKeysRead() uint64 { if m != nil { return m.KeysRead } return 0 } type SyncRegionRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Member *Member `protobuf:"bytes,2,opt,name=member" json:"member,omitempty"` // the follower PD will use the start index to locate historical changes // that require synchronization. StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SyncRegionRequest) Reset() { *m = SyncRegionRequest{} } func (m *SyncRegionRequest) String() string { return proto.CompactTextString(m) } func (*SyncRegionRequest) ProtoMessage() {} func (*SyncRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{73} } func (m *SyncRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SyncRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SyncRegionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SyncRegionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SyncRegionRequest.Merge(dst, src) } func (m *SyncRegionRequest) XXX_Size() int { return m.Size() } func (m *SyncRegionRequest) XXX_DiscardUnknown() { xxx_messageInfo_SyncRegionRequest.DiscardUnknown(m) } var xxx_messageInfo_SyncRegionRequest proto.InternalMessageInfo func (m *SyncRegionRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *SyncRegionRequest) GetMember() *Member { if m != nil { return m.Member } return nil } func (m *SyncRegionRequest) GetStartIndex() uint64 { if m != nil { return m.StartIndex } return 0 } type SyncRegionResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // the leader PD will send the repsonds include // changed regions records and the index of the first record. Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` RegionStats []*RegionStat `protobuf:"bytes,4,rep,name=region_stats,json=regionStats" json:"region_stats,omitempty"` RegionLeaders []*metapb.Peer `protobuf:"bytes,5,rep,name=region_leaders,json=regionLeaders" json:"region_leaders,omitempty"` // the buckets informations without stats. Buckets []*metapb.Buckets `protobuf:"bytes,6,rep,name=buckets" json:"buckets,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SyncRegionResponse) Reset() { *m = SyncRegionResponse{} } func (m *SyncRegionResponse) String() string { return proto.CompactTextString(m) } func (*SyncRegionResponse) ProtoMessage() {} func (*SyncRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{74} } func (m *SyncRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SyncRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SyncRegionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SyncRegionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SyncRegionResponse.Merge(dst, src) } func (m *SyncRegionResponse) XXX_Size() int { return m.Size() } func (m *SyncRegionResponse) XXX_DiscardUnknown() { xxx_messageInfo_SyncRegionResponse.DiscardUnknown(m) } var xxx_messageInfo_SyncRegionResponse proto.InternalMessageInfo func (m *SyncRegionResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *SyncRegionResponse) GetRegions() []*metapb.Region { if m != nil { return m.Regions } return nil } func (m *SyncRegionResponse) GetStartIndex() uint64 { if m != nil { return m.StartIndex } return 0 } func (m *SyncRegionResponse) GetRegionStats() []*RegionStat { if m != nil { return m.RegionStats } return nil } func (m *SyncRegionResponse) GetRegionLeaders() []*metapb.Peer { if m != nil { return m.RegionLeaders } return nil } func (m *SyncRegionResponse) GetBuckets() []*metapb.Buckets { if m != nil { return m.Buckets } return nil } type GetOperatorRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetOperatorRequest) Reset() { *m = GetOperatorRequest{} } func (m *GetOperatorRequest) String() string { return proto.CompactTextString(m) } func (*GetOperatorRequest) ProtoMessage() {} func (*GetOperatorRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{75} } func (m *GetOperatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetOperatorRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetOperatorRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetOperatorRequest.Merge(dst, src) } func (m *GetOperatorRequest) XXX_Size() int { return m.Size() } func (m *GetOperatorRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetOperatorRequest.DiscardUnknown(m) } var xxx_messageInfo_GetOperatorRequest proto.InternalMessageInfo func (m *GetOperatorRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetOperatorRequest) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } type GetOperatorResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` Desc []byte `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"` Status OperatorStatus `protobuf:"varint,4,opt,name=status,proto3,enum=pdpb.OperatorStatus" json:"status,omitempty"` Kind []byte `protobuf:"bytes,5,opt,name=kind,proto3" json:"kind,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetOperatorResponse) Reset() { *m = GetOperatorResponse{} } func (m *GetOperatorResponse) String() string { return proto.CompactTextString(m) } func (*GetOperatorResponse) ProtoMessage() {} func (*GetOperatorResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{76} } func (m *GetOperatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetOperatorResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetOperatorResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetOperatorResponse.Merge(dst, src) } func (m *GetOperatorResponse) XXX_Size() int { return m.Size() } func (m *GetOperatorResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetOperatorResponse.DiscardUnknown(m) } var xxx_messageInfo_GetOperatorResponse proto.InternalMessageInfo func (m *GetOperatorResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetOperatorResponse) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *GetOperatorResponse) GetDesc() []byte { if m != nil { return m.Desc } return nil } func (m *GetOperatorResponse) GetStatus() OperatorStatus { if m != nil { return m.Status } return OperatorStatus_SUCCESS } func (m *GetOperatorResponse) GetKind() []byte { if m != nil { return m.Kind } return nil } type SyncMaxTSRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` MaxTs *Timestamp `protobuf:"bytes,2,opt,name=max_ts,json=maxTs" json:"max_ts,omitempty"` // If skip_check is true, the sync will try to write the max_ts without checking whether it's bigger. SkipCheck bool `protobuf:"varint,3,opt,name=skip_check,json=skipCheck,proto3" json:"skip_check,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SyncMaxTSRequest) Reset() { *m = SyncMaxTSRequest{} } func (m *SyncMaxTSRequest) String() string { return proto.CompactTextString(m) } func (*SyncMaxTSRequest) ProtoMessage() {} func (*SyncMaxTSRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{77} } func (m *SyncMaxTSRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SyncMaxTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SyncMaxTSRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SyncMaxTSRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SyncMaxTSRequest.Merge(dst, src) } func (m *SyncMaxTSRequest) XXX_Size() int { return m.Size() } func (m *SyncMaxTSRequest) XXX_DiscardUnknown() { xxx_messageInfo_SyncMaxTSRequest.DiscardUnknown(m) } var xxx_messageInfo_SyncMaxTSRequest proto.InternalMessageInfo func (m *SyncMaxTSRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *SyncMaxTSRequest) GetMaxTs() *Timestamp { if m != nil { return m.MaxTs } return nil } func (m *SyncMaxTSRequest) GetSkipCheck() bool { if m != nil { return m.SkipCheck } return false } type SyncMaxTSResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` MaxLocalTs *Timestamp `protobuf:"bytes,2,opt,name=max_local_ts,json=maxLocalTs" json:"max_local_ts,omitempty"` SyncedDcs []string `protobuf:"bytes,3,rep,name=synced_dcs,json=syncedDcs" json:"synced_dcs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SyncMaxTSResponse) Reset() { *m = SyncMaxTSResponse{} } func (m *SyncMaxTSResponse) String() string { return proto.CompactTextString(m) } func (*SyncMaxTSResponse) ProtoMessage() {} func (*SyncMaxTSResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{78} } func (m *SyncMaxTSResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SyncMaxTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SyncMaxTSResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SyncMaxTSResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SyncMaxTSResponse.Merge(dst, src) } func (m *SyncMaxTSResponse) XXX_Size() int { return m.Size() } func (m *SyncMaxTSResponse) XXX_DiscardUnknown() { xxx_messageInfo_SyncMaxTSResponse.DiscardUnknown(m) } var xxx_messageInfo_SyncMaxTSResponse proto.InternalMessageInfo func (m *SyncMaxTSResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *SyncMaxTSResponse) GetMaxLocalTs() *Timestamp { if m != nil { return m.MaxLocalTs } return nil } func (m *SyncMaxTSResponse) GetSyncedDcs() []string { if m != nil { return m.SyncedDcs } return nil } type SplitRegionsRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys" json:"split_keys,omitempty"` RetryLimit uint64 `protobuf:"varint,3,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRegionsRequest) Reset() { *m = SplitRegionsRequest{} } func (m *SplitRegionsRequest) String() string { return proto.CompactTextString(m) } func (*SplitRegionsRequest) ProtoMessage() {} func (*SplitRegionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{79} } func (m *SplitRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRegionsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRegionsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRegionsRequest.Merge(dst, src) } func (m *SplitRegionsRequest) XXX_Size() int { return m.Size() } func (m *SplitRegionsRequest) XXX_DiscardUnknown() { xxx_messageInfo_SplitRegionsRequest.DiscardUnknown(m) } var xxx_messageInfo_SplitRegionsRequest proto.InternalMessageInfo func (m *SplitRegionsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *SplitRegionsRequest) GetSplitKeys() [][]byte { if m != nil { return m.SplitKeys } return nil } func (m *SplitRegionsRequest) GetRetryLimit() uint64 { if m != nil { return m.RetryLimit } return 0 } type SplitRegionsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` FinishedPercentage uint64 `protobuf:"varint,2,opt,name=finished_percentage,json=finishedPercentage,proto3" json:"finished_percentage,omitempty"` RegionsId []uint64 `protobuf:"varint,3,rep,packed,name=regions_id,json=regionsId" json:"regions_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRegionsResponse) Reset() { *m = SplitRegionsResponse{} } func (m *SplitRegionsResponse) String() string { return proto.CompactTextString(m) } func (*SplitRegionsResponse) ProtoMessage() {} func (*SplitRegionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{80} } func (m *SplitRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRegionsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRegionsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRegionsResponse.Merge(dst, src) } func (m *SplitRegionsResponse) XXX_Size() int { return m.Size() } func (m *SplitRegionsResponse) XXX_DiscardUnknown() { xxx_messageInfo_SplitRegionsResponse.DiscardUnknown(m) } var xxx_messageInfo_SplitRegionsResponse proto.InternalMessageInfo func (m *SplitRegionsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *SplitRegionsResponse) GetFinishedPercentage() uint64 { if m != nil { return m.FinishedPercentage } return 0 } func (m *SplitRegionsResponse) GetRegionsId() []uint64 { if m != nil { return m.RegionsId } return nil } type SplitAndScatterRegionsRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys" json:"split_keys,omitempty"` Group string `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"` RetryLimit uint64 `protobuf:"varint,4,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitAndScatterRegionsRequest) Reset() { *m = SplitAndScatterRegionsRequest{} } func (m *SplitAndScatterRegionsRequest) String() string { return proto.CompactTextString(m) } func (*SplitAndScatterRegionsRequest) ProtoMessage() {} func (*SplitAndScatterRegionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{81} } func (m *SplitAndScatterRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitAndScatterRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitAndScatterRegionsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitAndScatterRegionsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitAndScatterRegionsRequest.Merge(dst, src) } func (m *SplitAndScatterRegionsRequest) XXX_Size() int { return m.Size() } func (m *SplitAndScatterRegionsRequest) XXX_DiscardUnknown() { xxx_messageInfo_SplitAndScatterRegionsRequest.DiscardUnknown(m) } var xxx_messageInfo_SplitAndScatterRegionsRequest proto.InternalMessageInfo func (m *SplitAndScatterRegionsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *SplitAndScatterRegionsRequest) GetSplitKeys() [][]byte { if m != nil { return m.SplitKeys } return nil } func (m *SplitAndScatterRegionsRequest) GetGroup() string { if m != nil { return m.Group } return "" } func (m *SplitAndScatterRegionsRequest) GetRetryLimit() uint64 { if m != nil { return m.RetryLimit } return 0 } type SplitAndScatterRegionsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` SplitFinishedPercentage uint64 `protobuf:"varint,2,opt,name=split_finished_percentage,json=splitFinishedPercentage,proto3" json:"split_finished_percentage,omitempty"` ScatterFinishedPercentage uint64 `protobuf:"varint,3,opt,name=scatter_finished_percentage,json=scatterFinishedPercentage,proto3" json:"scatter_finished_percentage,omitempty"` RegionsId []uint64 `protobuf:"varint,4,rep,packed,name=regions_id,json=regionsId" json:"regions_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitAndScatterRegionsResponse) Reset() { *m = SplitAndScatterRegionsResponse{} } func (m *SplitAndScatterRegionsResponse) String() string { return proto.CompactTextString(m) } func (*SplitAndScatterRegionsResponse) ProtoMessage() {} func (*SplitAndScatterRegionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{82} } func (m *SplitAndScatterRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitAndScatterRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitAndScatterRegionsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitAndScatterRegionsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitAndScatterRegionsResponse.Merge(dst, src) } func (m *SplitAndScatterRegionsResponse) XXX_Size() int { return m.Size() } func (m *SplitAndScatterRegionsResponse) XXX_DiscardUnknown() { xxx_messageInfo_SplitAndScatterRegionsResponse.DiscardUnknown(m) } var xxx_messageInfo_SplitAndScatterRegionsResponse proto.InternalMessageInfo func (m *SplitAndScatterRegionsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *SplitAndScatterRegionsResponse) GetSplitFinishedPercentage() uint64 { if m != nil { return m.SplitFinishedPercentage } return 0 } func (m *SplitAndScatterRegionsResponse) GetScatterFinishedPercentage() uint64 { if m != nil { return m.ScatterFinishedPercentage } return 0 } func (m *SplitAndScatterRegionsResponse) GetRegionsId() []uint64 { if m != nil { return m.RegionsId } return nil } type GetDCLocationInfoRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` DcLocation string `protobuf:"bytes,2,opt,name=dc_location,json=dcLocation,proto3" json:"dc_location,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetDCLocationInfoRequest) Reset() { *m = GetDCLocationInfoRequest{} } func (m *GetDCLocationInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetDCLocationInfoRequest) ProtoMessage() {} func (*GetDCLocationInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{83} } func (m *GetDCLocationInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetDCLocationInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetDCLocationInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetDCLocationInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetDCLocationInfoRequest.Merge(dst, src) } func (m *GetDCLocationInfoRequest) XXX_Size() int { return m.Size() } func (m *GetDCLocationInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetDCLocationInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_GetDCLocationInfoRequest proto.InternalMessageInfo func (m *GetDCLocationInfoRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *GetDCLocationInfoRequest) GetDcLocation() string { if m != nil { return m.DcLocation } return "" } type GetDCLocationInfoResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // suffix sign Suffix int32 `protobuf:"varint,2,opt,name=suffix,proto3" json:"suffix,omitempty"` // max_ts will be included into this response if PD leader think the receiver needs, // which it's set when the number of the max suffix bits changes. MaxTs *Timestamp `protobuf:"bytes,3,opt,name=max_ts,json=maxTs" json:"max_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetDCLocationInfoResponse) Reset() { *m = GetDCLocationInfoResponse{} } func (m *GetDCLocationInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetDCLocationInfoResponse) ProtoMessage() {} func (*GetDCLocationInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{84} } func (m *GetDCLocationInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetDCLocationInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetDCLocationInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetDCLocationInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetDCLocationInfoResponse.Merge(dst, src) } func (m *GetDCLocationInfoResponse) XXX_Size() int { return m.Size() } func (m *GetDCLocationInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_GetDCLocationInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_GetDCLocationInfoResponse proto.InternalMessageInfo func (m *GetDCLocationInfoResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func (m *GetDCLocationInfoResponse) GetSuffix() int32 { if m != nil { return m.Suffix } return 0 } func (m *GetDCLocationInfoResponse) GetMaxTs() *Timestamp { if m != nil { return m.MaxTs } return nil } type QueryStats struct { GC uint64 `protobuf:"varint,1,opt,name=GC,proto3" json:"GC,omitempty"` Get uint64 `protobuf:"varint,2,opt,name=Get,proto3" json:"Get,omitempty"` Scan uint64 `protobuf:"varint,3,opt,name=Scan,proto3" json:"Scan,omitempty"` Coprocessor uint64 `protobuf:"varint,4,opt,name=Coprocessor,proto3" json:"Coprocessor,omitempty"` Delete uint64 `protobuf:"varint,5,opt,name=Delete,proto3" json:"Delete,omitempty"` DeleteRange uint64 `protobuf:"varint,6,opt,name=DeleteRange,proto3" json:"DeleteRange,omitempty"` Put uint64 `protobuf:"varint,7,opt,name=Put,proto3" json:"Put,omitempty"` Prewrite uint64 `protobuf:"varint,8,opt,name=Prewrite,proto3" json:"Prewrite,omitempty"` AcquirePessimisticLock uint64 `protobuf:"varint,9,opt,name=AcquirePessimisticLock,proto3" json:"AcquirePessimisticLock,omitempty"` Commit uint64 `protobuf:"varint,10,opt,name=Commit,proto3" json:"Commit,omitempty"` Rollback uint64 `protobuf:"varint,11,opt,name=Rollback,proto3" json:"Rollback,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *QueryStats) Reset() { *m = QueryStats{} } func (m *QueryStats) String() string { return proto.CompactTextString(m) } func (*QueryStats) ProtoMessage() {} func (*QueryStats) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{85} } func (m *QueryStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *QueryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_QueryStats.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *QueryStats) XXX_Merge(src proto.Message) { xxx_messageInfo_QueryStats.Merge(dst, src) } func (m *QueryStats) XXX_Size() int { return m.Size() } func (m *QueryStats) XXX_DiscardUnknown() { xxx_messageInfo_QueryStats.DiscardUnknown(m) } var xxx_messageInfo_QueryStats proto.InternalMessageInfo func (m *QueryStats) GetGC() uint64 { if m != nil { return m.GC } return 0 } func (m *QueryStats) GetGet() uint64 { if m != nil { return m.Get } return 0 } func (m *QueryStats) GetScan() uint64 { if m != nil { return m.Scan } return 0 } func (m *QueryStats) GetCoprocessor() uint64 { if m != nil { return m.Coprocessor } return 0 } func (m *QueryStats) GetDelete() uint64 { if m != nil { return m.Delete } return 0 } func (m *QueryStats) GetDeleteRange() uint64 { if m != nil { return m.DeleteRange } return 0 } func (m *QueryStats) GetPut() uint64 { if m != nil { return m.Put } return 0 } func (m *QueryStats) GetPrewrite() uint64 { if m != nil { return m.Prewrite } return 0 } func (m *QueryStats) GetAcquirePessimisticLock() uint64 { if m != nil { return m.AcquirePessimisticLock } return 0 } func (m *QueryStats) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } func (m *QueryStats) GetRollback() uint64 { if m != nil { return m.Rollback } return 0 } type ReportBucketsRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` Buckets *metapb.Buckets `protobuf:"bytes,3,opt,name=buckets" json:"buckets,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportBucketsRequest) Reset() { *m = ReportBucketsRequest{} } func (m *ReportBucketsRequest) String() string { return proto.CompactTextString(m) } func (*ReportBucketsRequest) ProtoMessage() {} func (*ReportBucketsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{86} } func (m *ReportBucketsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportBucketsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportBucketsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportBucketsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportBucketsRequest.Merge(dst, src) } func (m *ReportBucketsRequest) XXX_Size() int { return m.Size() } func (m *ReportBucketsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReportBucketsRequest.DiscardUnknown(m) } var xxx_messageInfo_ReportBucketsRequest proto.InternalMessageInfo func (m *ReportBucketsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *ReportBucketsRequest) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *ReportBucketsRequest) GetBuckets() *metapb.Buckets { if m != nil { return m.Buckets } return nil } type ReportBucketsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportBucketsResponse) Reset() { *m = ReportBucketsResponse{} } func (m *ReportBucketsResponse) String() string { return proto.CompactTextString(m) } func (*ReportBucketsResponse) ProtoMessage() {} func (*ReportBucketsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{87} } func (m *ReportBucketsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportBucketsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportBucketsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportBucketsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportBucketsResponse.Merge(dst, src) } func (m *ReportBucketsResponse) XXX_Size() int { return m.Size() } func (m *ReportBucketsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReportBucketsResponse.DiscardUnknown(m) } var xxx_messageInfo_ReportBucketsResponse proto.InternalMessageInfo func (m *ReportBucketsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } type ReportMinResolvedTsRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` MinResolvedTs uint64 `protobuf:"varint,3,opt,name=min_resolved_ts,json=minResolvedTs,proto3" json:"min_resolved_ts,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportMinResolvedTsRequest) Reset() { *m = ReportMinResolvedTsRequest{} } func (m *ReportMinResolvedTsRequest) String() string { return proto.CompactTextString(m) } func (*ReportMinResolvedTsRequest) ProtoMessage() {} func (*ReportMinResolvedTsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{88} } func (m *ReportMinResolvedTsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportMinResolvedTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportMinResolvedTsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportMinResolvedTsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportMinResolvedTsRequest.Merge(dst, src) } func (m *ReportMinResolvedTsRequest) XXX_Size() int { return m.Size() } func (m *ReportMinResolvedTsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReportMinResolvedTsRequest.DiscardUnknown(m) } var xxx_messageInfo_ReportMinResolvedTsRequest proto.InternalMessageInfo func (m *ReportMinResolvedTsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } func (m *ReportMinResolvedTsRequest) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } func (m *ReportMinResolvedTsRequest) GetMinResolvedTs() uint64 { if m != nil { return m.MinResolvedTs } return 0 } type ReportMinResolvedTsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReportMinResolvedTsResponse) Reset() { *m = ReportMinResolvedTsResponse{} } func (m *ReportMinResolvedTsResponse) String() string { return proto.CompactTextString(m) } func (*ReportMinResolvedTsResponse) ProtoMessage() {} func (*ReportMinResolvedTsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_pdpb_3495b43081031f06, []int{89} } func (m *ReportMinResolvedTsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReportMinResolvedTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReportMinResolvedTsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReportMinResolvedTsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReportMinResolvedTsResponse.Merge(dst, src) } func (m *ReportMinResolvedTsResponse) XXX_Size() int { return m.Size() } func (m *ReportMinResolvedTsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReportMinResolvedTsResponse.DiscardUnknown(m) } var xxx_messageInfo_ReportMinResolvedTsResponse proto.InternalMessageInfo func (m *ReportMinResolvedTsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } func init() { proto.RegisterType((*WatchGlobalConfigRequest)(nil), "pdpb.WatchGlobalConfigRequest") proto.RegisterType((*WatchGlobalConfigResponse)(nil), "pdpb.WatchGlobalConfigResponse") proto.RegisterType((*StoreGlobalConfigRequest)(nil), "pdpb.StoreGlobalConfigRequest") proto.RegisterType((*StoreGlobalConfigResponse)(nil), "pdpb.StoreGlobalConfigResponse") proto.RegisterType((*LoadGlobalConfigRequest)(nil), "pdpb.LoadGlobalConfigRequest") proto.RegisterType((*LoadGlobalConfigResponse)(nil), "pdpb.LoadGlobalConfigResponse") proto.RegisterType((*GlobalConfigItem)(nil), "pdpb.GlobalConfigItem") proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader") proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader") proto.RegisterType((*Error)(nil), "pdpb.Error") proto.RegisterType((*TsoRequest)(nil), "pdpb.TsoRequest") proto.RegisterType((*Timestamp)(nil), "pdpb.Timestamp") proto.RegisterType((*TsoResponse)(nil), "pdpb.TsoResponse") proto.RegisterType((*BootstrapRequest)(nil), "pdpb.BootstrapRequest") proto.RegisterType((*BootstrapResponse)(nil), "pdpb.BootstrapResponse") proto.RegisterType((*IsBootstrappedRequest)(nil), "pdpb.IsBootstrappedRequest") proto.RegisterType((*IsBootstrappedResponse)(nil), "pdpb.IsBootstrappedResponse") proto.RegisterType((*AllocIDRequest)(nil), "pdpb.AllocIDRequest") proto.RegisterType((*AllocIDResponse)(nil), "pdpb.AllocIDResponse") proto.RegisterType((*GetStoreRequest)(nil), "pdpb.GetStoreRequest") proto.RegisterType((*GetStoreResponse)(nil), "pdpb.GetStoreResponse") proto.RegisterType((*PutStoreRequest)(nil), "pdpb.PutStoreRequest") proto.RegisterType((*PutStoreResponse)(nil), "pdpb.PutStoreResponse") proto.RegisterType((*GetAllStoresRequest)(nil), "pdpb.GetAllStoresRequest") proto.RegisterType((*GetAllStoresResponse)(nil), "pdpb.GetAllStoresResponse") proto.RegisterType((*GetRegionRequest)(nil), "pdpb.GetRegionRequest") proto.RegisterType((*GetRegionResponse)(nil), "pdpb.GetRegionResponse") proto.RegisterType((*GetRegionByIDRequest)(nil), "pdpb.GetRegionByIDRequest") proto.RegisterType((*ScanRegionsRequest)(nil), "pdpb.ScanRegionsRequest") proto.RegisterType((*Region)(nil), "pdpb.Region") proto.RegisterType((*ScanRegionsResponse)(nil), "pdpb.ScanRegionsResponse") proto.RegisterType((*GetClusterConfigRequest)(nil), "pdpb.GetClusterConfigRequest") proto.RegisterType((*GetClusterConfigResponse)(nil), "pdpb.GetClusterConfigResponse") proto.RegisterType((*PutClusterConfigRequest)(nil), "pdpb.PutClusterConfigRequest") proto.RegisterType((*PutClusterConfigResponse)(nil), "pdpb.PutClusterConfigResponse") proto.RegisterType((*Member)(nil), "pdpb.Member") proto.RegisterType((*GetMembersRequest)(nil), "pdpb.GetMembersRequest") proto.RegisterType((*GetMembersResponse)(nil), "pdpb.GetMembersResponse") proto.RegisterMapType((map[string]*Member)(nil), "pdpb.GetMembersResponse.TsoAllocatorLeadersEntry") proto.RegisterType((*PeerStats)(nil), "pdpb.PeerStats") proto.RegisterType((*RegionHeartbeatRequest)(nil), "pdpb.RegionHeartbeatRequest") proto.RegisterType((*ChangePeer)(nil), "pdpb.ChangePeer") proto.RegisterType((*ChangePeerV2)(nil), "pdpb.ChangePeerV2") proto.RegisterType((*TransferLeader)(nil), "pdpb.TransferLeader") proto.RegisterType((*Merge)(nil), "pdpb.Merge") proto.RegisterType((*SplitRegion)(nil), "pdpb.SplitRegion") proto.RegisterType((*RegionHeartbeatResponse)(nil), "pdpb.RegionHeartbeatResponse") proto.RegisterType((*AskSplitRequest)(nil), "pdpb.AskSplitRequest") proto.RegisterType((*AskSplitResponse)(nil), "pdpb.AskSplitResponse") proto.RegisterType((*ReportSplitRequest)(nil), "pdpb.ReportSplitRequest") proto.RegisterType((*ReportSplitResponse)(nil), "pdpb.ReportSplitResponse") proto.RegisterType((*AskBatchSplitRequest)(nil), "pdpb.AskBatchSplitRequest") proto.RegisterType((*SplitID)(nil), "pdpb.SplitID") proto.RegisterType((*AskBatchSplitResponse)(nil), "pdpb.AskBatchSplitResponse") proto.RegisterType((*ReportBatchSplitRequest)(nil), "pdpb.ReportBatchSplitRequest") proto.RegisterType((*ReportBatchSplitResponse)(nil), "pdpb.ReportBatchSplitResponse") proto.RegisterType((*TimeInterval)(nil), "pdpb.TimeInterval") proto.RegisterType((*RecordPair)(nil), "pdpb.RecordPair") proto.RegisterType((*PeerStat)(nil), "pdpb.PeerStat") proto.RegisterType((*StoreStats)(nil), "pdpb.StoreStats") proto.RegisterType((*PeerReport)(nil), "pdpb.PeerReport") proto.RegisterType((*StoreReport)(nil), "pdpb.StoreReport") proto.RegisterType((*StoreHeartbeatRequest)(nil), "pdpb.StoreHeartbeatRequest") proto.RegisterType((*RecoveryPlan)(nil), "pdpb.RecoveryPlan") proto.RegisterType((*StoreHeartbeatResponse)(nil), "pdpb.StoreHeartbeatResponse") proto.RegisterType((*ScatterRegionRequest)(nil), "pdpb.ScatterRegionRequest") proto.RegisterType((*ScatterRegionResponse)(nil), "pdpb.ScatterRegionResponse") proto.RegisterType((*GetGCSafePointRequest)(nil), "pdpb.GetGCSafePointRequest") proto.RegisterType((*GetGCSafePointResponse)(nil), "pdpb.GetGCSafePointResponse") proto.RegisterType((*UpdateGCSafePointRequest)(nil), "pdpb.UpdateGCSafePointRequest") proto.RegisterType((*UpdateGCSafePointResponse)(nil), "pdpb.UpdateGCSafePointResponse") proto.RegisterType((*UpdateServiceGCSafePointRequest)(nil), "pdpb.UpdateServiceGCSafePointRequest") proto.RegisterType((*UpdateServiceGCSafePointResponse)(nil), "pdpb.UpdateServiceGCSafePointResponse") proto.RegisterType((*RegionStat)(nil), "pdpb.RegionStat") proto.RegisterType((*SyncRegionRequest)(nil), "pdpb.SyncRegionRequest") proto.RegisterType((*SyncRegionResponse)(nil), "pdpb.SyncRegionResponse") proto.RegisterType((*GetOperatorRequest)(nil), "pdpb.GetOperatorRequest") proto.RegisterType((*GetOperatorResponse)(nil), "pdpb.GetOperatorResponse") proto.RegisterType((*SyncMaxTSRequest)(nil), "pdpb.SyncMaxTSRequest") proto.RegisterType((*SyncMaxTSResponse)(nil), "pdpb.SyncMaxTSResponse") proto.RegisterType((*SplitRegionsRequest)(nil), "pdpb.SplitRegionsRequest") proto.RegisterType((*SplitRegionsResponse)(nil), "pdpb.SplitRegionsResponse") proto.RegisterType((*SplitAndScatterRegionsRequest)(nil), "pdpb.SplitAndScatterRegionsRequest") proto.RegisterType((*SplitAndScatterRegionsResponse)(nil), "pdpb.SplitAndScatterRegionsResponse") proto.RegisterType((*GetDCLocationInfoRequest)(nil), "pdpb.GetDCLocationInfoRequest") proto.RegisterType((*GetDCLocationInfoResponse)(nil), "pdpb.GetDCLocationInfoResponse") proto.RegisterType((*QueryStats)(nil), "pdpb.QueryStats") proto.RegisterType((*ReportBucketsRequest)(nil), "pdpb.ReportBucketsRequest") proto.RegisterType((*ReportBucketsResponse)(nil), "pdpb.ReportBucketsResponse") proto.RegisterType((*ReportMinResolvedTsRequest)(nil), "pdpb.ReportMinResolvedTsRequest") proto.RegisterType((*ReportMinResolvedTsResponse)(nil), "pdpb.ReportMinResolvedTsResponse") proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value) proto.RegisterEnum("pdpb.CheckPolicy", CheckPolicy_name, CheckPolicy_value) proto.RegisterEnum("pdpb.OperatorStatus", OperatorStatus_name, OperatorStatus_value) proto.RegisterEnum("pdpb.QueryKind", QueryKind_name, QueryKind_value) } // 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 // Client API for PD service type PDClient interface { // GetMembers get the member list of this cluster. It does not require // the cluster_id in request matchs the id of this cluster. GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) } type pDClient struct { cc *grpc.ClientConn } func NewPDClient(cc *grpc.ClientConn) PDClient { return &pDClient{cc} } func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) { out := new(GetMembersResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[0], "/pdpb.PD/Tso", opts...) if err != nil { return nil, err } x := &pDTsoClient{stream} return x, nil } type PD_TsoClient interface { Send(*TsoRequest) error Recv() (*TsoResponse, error) grpc.ClientStream } type pDTsoClient struct { grpc.ClientStream } func (x *pDTsoClient) Send(m *TsoRequest) error { return x.ClientStream.SendMsg(m) } func (x *pDTsoClient) Recv() (*TsoResponse, error) { m := new(TsoResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) { out := new(BootstrapResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) { out := new(IsBootstrappedResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) { out := new(AllocIDResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) { out := new(GetStoreResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) { out := new(PutStoreResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) { out := new(GetAllStoresResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) { out := new(StoreHeartbeatResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[1], "/pdpb.PD/RegionHeartbeat", opts...) if err != nil { return nil, err } x := &pDRegionHeartbeatClient{stream} return x, nil } type PD_RegionHeartbeatClient interface { Send(*RegionHeartbeatRequest) error Recv() (*RegionHeartbeatResponse, error) grpc.ClientStream } type pDRegionHeartbeatClient struct { grpc.ClientStream } func (x *pDRegionHeartbeatClient) Send(m *RegionHeartbeatRequest) error { return x.ClientStream.SendMsg(m) } func (x *pDRegionHeartbeatClient) Recv() (*RegionHeartbeatResponse, error) { m := new(RegionHeartbeatResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) { out := new(ScanRegionsResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/ScanRegions", in, out, opts...) if err != nil { return nil, err } return out, nil } // Deprecated: Do not use. func (c *pDClient) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) { out := new(AskSplitResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, opts...) if err != nil { return nil, err } return out, nil } // Deprecated: Do not use. func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) { out := new(ReportSplitResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) { out := new(AskBatchSplitResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) { out := new(ReportBatchSplitResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) { out := new(GetClusterConfigResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) { out := new(PutClusterConfigResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) { out := new(ScatterRegionResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) { out := new(GetGCSafePointResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) { out := new(UpdateGCSafePointResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) { out := new(UpdateServiceGCSafePointResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateServiceGCSafePoint", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[2], "/pdpb.PD/SyncRegions", opts...) if err != nil { return nil, err } x := &pDSyncRegionsClient{stream} return x, nil } type PD_SyncRegionsClient interface { Send(*SyncRegionRequest) error Recv() (*SyncRegionResponse, error) grpc.ClientStream } type pDSyncRegionsClient struct { grpc.ClientStream } func (x *pDSyncRegionsClient) Send(m *SyncRegionRequest) error { return x.ClientStream.SendMsg(m) } func (x *pDSyncRegionsClient) Recv() (*SyncRegionResponse, error) { m := new(SyncRegionResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *pDClient) GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) { out := new(GetOperatorResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetOperator", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) { out := new(SyncMaxTSResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/SyncMaxTS", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) { out := new(SplitRegionsResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/SplitRegions", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) { out := new(SplitAndScatterRegionsResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/SplitAndScatterRegions", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) { out := new(GetDCLocationInfoResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/GetDCLocationInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) { out := new(StoreGlobalConfigResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/StoreGlobalConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) { out := new(LoadGlobalConfigResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/LoadGlobalConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *pDClient) WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[3], "/pdpb.PD/WatchGlobalConfig", opts...) if err != nil { return nil, err } x := &pDWatchGlobalConfigClient{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 PD_WatchGlobalConfigClient interface { Recv() (*WatchGlobalConfigResponse, error) grpc.ClientStream } type pDWatchGlobalConfigClient struct { grpc.ClientStream } func (x *pDWatchGlobalConfigClient) Recv() (*WatchGlobalConfigResponse, error) { m := new(WatchGlobalConfigResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *pDClient) ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[4], "/pdpb.PD/ReportBuckets", opts...) if err != nil { return nil, err } x := &pDReportBucketsClient{stream} return x, nil } type PD_ReportBucketsClient interface { Send(*ReportBucketsRequest) error CloseAndRecv() (*ReportBucketsResponse, error) grpc.ClientStream } type pDReportBucketsClient struct { grpc.ClientStream } func (x *pDReportBucketsClient) Send(m *ReportBucketsRequest) error { return x.ClientStream.SendMsg(m) } func (x *pDReportBucketsClient) CloseAndRecv() (*ReportBucketsResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(ReportBucketsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *pDClient) ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) { out := new(ReportMinResolvedTsResponse) err := c.cc.Invoke(ctx, "/pdpb.PD/ReportMinResolvedTS", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for PD service type PDServer interface { // GetMembers get the member list of this cluster. It does not require // the cluster_id in request matchs the id of this cluster. GetMembers(context.Context, *GetMembersRequest) (*GetMembersResponse, error) Tso(PD_TsoServer) error Bootstrap(context.Context, *BootstrapRequest) (*BootstrapResponse, error) IsBootstrapped(context.Context, *IsBootstrappedRequest) (*IsBootstrappedResponse, error) AllocID(context.Context, *AllocIDRequest) (*AllocIDResponse, error) GetStore(context.Context, *GetStoreRequest) (*GetStoreResponse, error) PutStore(context.Context, *PutStoreRequest) (*PutStoreResponse, error) GetAllStores(context.Context, *GetAllStoresRequest) (*GetAllStoresResponse, error) StoreHeartbeat(context.Context, *StoreHeartbeatRequest) (*StoreHeartbeatResponse, error) RegionHeartbeat(PD_RegionHeartbeatServer) error GetRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) GetPrevRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) GetRegionByID(context.Context, *GetRegionByIDRequest) (*GetRegionResponse, error) ScanRegions(context.Context, *ScanRegionsRequest) (*ScanRegionsResponse, error) AskSplit(context.Context, *AskSplitRequest) (*AskSplitResponse, error) ReportSplit(context.Context, *ReportSplitRequest) (*ReportSplitResponse, error) AskBatchSplit(context.Context, *AskBatchSplitRequest) (*AskBatchSplitResponse, error) ReportBatchSplit(context.Context, *ReportBatchSplitRequest) (*ReportBatchSplitResponse, error) GetClusterConfig(context.Context, *GetClusterConfigRequest) (*GetClusterConfigResponse, error) PutClusterConfig(context.Context, *PutClusterConfigRequest) (*PutClusterConfigResponse, error) ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) GetGCSafePoint(context.Context, *GetGCSafePointRequest) (*GetGCSafePointResponse, error) UpdateGCSafePoint(context.Context, *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) UpdateServiceGCSafePoint(context.Context, *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) SyncRegions(PD_SyncRegionsServer) error GetOperator(context.Context, *GetOperatorRequest) (*GetOperatorResponse, error) SyncMaxTS(context.Context, *SyncMaxTSRequest) (*SyncMaxTSResponse, error) SplitRegions(context.Context, *SplitRegionsRequest) (*SplitRegionsResponse, error) SplitAndScatterRegions(context.Context, *SplitAndScatterRegionsRequest) (*SplitAndScatterRegionsResponse, error) GetDCLocationInfo(context.Context, *GetDCLocationInfoRequest) (*GetDCLocationInfoResponse, error) StoreGlobalConfig(context.Context, *StoreGlobalConfigRequest) (*StoreGlobalConfigResponse, error) LoadGlobalConfig(context.Context, *LoadGlobalConfigRequest) (*LoadGlobalConfigResponse, error) WatchGlobalConfig(*WatchGlobalConfigRequest, PD_WatchGlobalConfigServer) error ReportBuckets(PD_ReportBucketsServer) error ReportMinResolvedTS(context.Context, *ReportMinResolvedTsRequest) (*ReportMinResolvedTsResponse, error) } func RegisterPDServer(s *grpc.Server, srv PDServer) { s.RegisterService(&_PD_serviceDesc, srv) } func _PD_GetMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetMembersRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetMembers(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetMembers", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetMembers(ctx, req.(*GetMembersRequest)) } return interceptor(ctx, in, info, handler) } func _PD_Tso_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(PDServer).Tso(&pDTsoServer{stream}) } type PD_TsoServer interface { Send(*TsoResponse) error Recv() (*TsoRequest, error) grpc.ServerStream } type pDTsoServer struct { grpc.ServerStream } func (x *pDTsoServer) Send(m *TsoResponse) error { return x.ServerStream.SendMsg(m) } func (x *pDTsoServer) Recv() (*TsoRequest, error) { m := new(TsoRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _PD_Bootstrap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(BootstrapRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).Bootstrap(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/Bootstrap", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).Bootstrap(ctx, req.(*BootstrapRequest)) } return interceptor(ctx, in, info, handler) } func _PD_IsBootstrapped_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(IsBootstrappedRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).IsBootstrapped(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/IsBootstrapped", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).IsBootstrapped(ctx, req.(*IsBootstrappedRequest)) } return interceptor(ctx, in, info, handler) } func _PD_AllocID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AllocIDRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).AllocID(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/AllocID", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).AllocID(ctx, req.(*AllocIDRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetStoreRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetStore(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetStore", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetStore(ctx, req.(*GetStoreRequest)) } return interceptor(ctx, in, info, handler) } func _PD_PutStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PutStoreRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).PutStore(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/PutStore", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).PutStore(ctx, req.(*PutStoreRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetAllStores_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetAllStoresRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetAllStores(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetAllStores", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetAllStores(ctx, req.(*GetAllStoresRequest)) } return interceptor(ctx, in, info, handler) } func _PD_StoreHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StoreHeartbeatRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).StoreHeartbeat(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/StoreHeartbeat", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).StoreHeartbeat(ctx, req.(*StoreHeartbeatRequest)) } return interceptor(ctx, in, info, handler) } func _PD_RegionHeartbeat_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(PDServer).RegionHeartbeat(&pDRegionHeartbeatServer{stream}) } type PD_RegionHeartbeatServer interface { Send(*RegionHeartbeatResponse) error Recv() (*RegionHeartbeatRequest, error) grpc.ServerStream } type pDRegionHeartbeatServer struct { grpc.ServerStream } func (x *pDRegionHeartbeatServer) Send(m *RegionHeartbeatResponse) error { return x.ServerStream.SendMsg(m) } func (x *pDRegionHeartbeatServer) Recv() (*RegionHeartbeatRequest, error) { m := new(RegionHeartbeatRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _PD_GetRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetRegionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetRegion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetRegion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetRegion(ctx, req.(*GetRegionRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetPrevRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetRegionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetPrevRegion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetPrevRegion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetPrevRegion(ctx, req.(*GetRegionRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetRegionByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetRegionByIDRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetRegionByID(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetRegionByID", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetRegionByID(ctx, req.(*GetRegionByIDRequest)) } return interceptor(ctx, in, info, handler) } func _PD_ScanRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ScanRegionsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).ScanRegions(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/ScanRegions", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).ScanRegions(ctx, req.(*ScanRegionsRequest)) } return interceptor(ctx, in, info, handler) } func _PD_AskSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AskSplitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).AskSplit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/AskSplit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).AskSplit(ctx, req.(*AskSplitRequest)) } return interceptor(ctx, in, info, handler) } func _PD_ReportSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ReportSplitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).ReportSplit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/ReportSplit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).ReportSplit(ctx, req.(*ReportSplitRequest)) } return interceptor(ctx, in, info, handler) } func _PD_AskBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AskBatchSplitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).AskBatchSplit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/AskBatchSplit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).AskBatchSplit(ctx, req.(*AskBatchSplitRequest)) } return interceptor(ctx, in, info, handler) } func _PD_ReportBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ReportBatchSplitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).ReportBatchSplit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/ReportBatchSplit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).ReportBatchSplit(ctx, req.(*ReportBatchSplitRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetClusterConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetClusterConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetClusterConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetClusterConfig(ctx, req.(*GetClusterConfigRequest)) } return interceptor(ctx, in, info, handler) } func _PD_PutClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PutClusterConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).PutClusterConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/PutClusterConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).PutClusterConfig(ctx, req.(*PutClusterConfigRequest)) } return interceptor(ctx, in, info, handler) } func _PD_ScatterRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ScatterRegionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).ScatterRegion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/ScatterRegion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).ScatterRegion(ctx, req.(*ScatterRegionRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetGCSafePointRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetGCSafePoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetGCSafePoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetGCSafePoint(ctx, req.(*GetGCSafePointRequest)) } return interceptor(ctx, in, info, handler) } func _PD_UpdateGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateGCSafePointRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).UpdateGCSafePoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/UpdateGCSafePoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*UpdateGCSafePointRequest)) } return interceptor(ctx, in, info, handler) } func _PD_UpdateServiceGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateServiceGCSafePointRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).UpdateServiceGCSafePoint(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/UpdateServiceGCSafePoint", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).UpdateServiceGCSafePoint(ctx, req.(*UpdateServiceGCSafePointRequest)) } return interceptor(ctx, in, info, handler) } func _PD_SyncRegions_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(PDServer).SyncRegions(&pDSyncRegionsServer{stream}) } type PD_SyncRegionsServer interface { Send(*SyncRegionResponse) error Recv() (*SyncRegionRequest, error) grpc.ServerStream } type pDSyncRegionsServer struct { grpc.ServerStream } func (x *pDSyncRegionsServer) Send(m *SyncRegionResponse) error { return x.ServerStream.SendMsg(m) } func (x *pDSyncRegionsServer) Recv() (*SyncRegionRequest, error) { m := new(SyncRegionRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _PD_GetOperator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetOperatorRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetOperator(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetOperator", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetOperator(ctx, req.(*GetOperatorRequest)) } return interceptor(ctx, in, info, handler) } func _PD_SyncMaxTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SyncMaxTSRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).SyncMaxTS(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/SyncMaxTS", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).SyncMaxTS(ctx, req.(*SyncMaxTSRequest)) } return interceptor(ctx, in, info, handler) } func _PD_SplitRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SplitRegionsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).SplitRegions(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/SplitRegions", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).SplitRegions(ctx, req.(*SplitRegionsRequest)) } return interceptor(ctx, in, info, handler) } func _PD_SplitAndScatterRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SplitAndScatterRegionsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).SplitAndScatterRegions(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/SplitAndScatterRegions", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).SplitAndScatterRegions(ctx, req.(*SplitAndScatterRegionsRequest)) } return interceptor(ctx, in, info, handler) } func _PD_GetDCLocationInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetDCLocationInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).GetDCLocationInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/GetDCLocationInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).GetDCLocationInfo(ctx, req.(*GetDCLocationInfoRequest)) } return interceptor(ctx, in, info, handler) } func _PD_StoreGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StoreGlobalConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).StoreGlobalConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/StoreGlobalConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).StoreGlobalConfig(ctx, req.(*StoreGlobalConfigRequest)) } return interceptor(ctx, in, info, handler) } func _PD_LoadGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(LoadGlobalConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).LoadGlobalConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/LoadGlobalConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).LoadGlobalConfig(ctx, req.(*LoadGlobalConfigRequest)) } return interceptor(ctx, in, info, handler) } func _PD_WatchGlobalConfig_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(WatchGlobalConfigRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(PDServer).WatchGlobalConfig(m, &pDWatchGlobalConfigServer{stream}) } type PD_WatchGlobalConfigServer interface { Send(*WatchGlobalConfigResponse) error grpc.ServerStream } type pDWatchGlobalConfigServer struct { grpc.ServerStream } func (x *pDWatchGlobalConfigServer) Send(m *WatchGlobalConfigResponse) error { return x.ServerStream.SendMsg(m) } func _PD_ReportBuckets_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(PDServer).ReportBuckets(&pDReportBucketsServer{stream}) } type PD_ReportBucketsServer interface { SendAndClose(*ReportBucketsResponse) error Recv() (*ReportBucketsRequest, error) grpc.ServerStream } type pDReportBucketsServer struct { grpc.ServerStream } func (x *pDReportBucketsServer) SendAndClose(m *ReportBucketsResponse) error { return x.ServerStream.SendMsg(m) } func (x *pDReportBucketsServer) Recv() (*ReportBucketsRequest, error) { m := new(ReportBucketsRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _PD_ReportMinResolvedTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ReportMinResolvedTsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(PDServer).ReportMinResolvedTS(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pdpb.PD/ReportMinResolvedTS", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PDServer).ReportMinResolvedTS(ctx, req.(*ReportMinResolvedTsRequest)) } return interceptor(ctx, in, info, handler) } var _PD_serviceDesc = grpc.ServiceDesc{ ServiceName: "pdpb.PD", HandlerType: (*PDServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "GetMembers", Handler: _PD_GetMembers_Handler, }, { MethodName: "Bootstrap", Handler: _PD_Bootstrap_Handler, }, { MethodName: "IsBootstrapped", Handler: _PD_IsBootstrapped_Handler, }, { MethodName: "AllocID", Handler: _PD_AllocID_Handler, }, { MethodName: "GetStore", Handler: _PD_GetStore_Handler, }, { MethodName: "PutStore", Handler: _PD_PutStore_Handler, }, { MethodName: "GetAllStores", Handler: _PD_GetAllStores_Handler, }, { MethodName: "StoreHeartbeat", Handler: _PD_StoreHeartbeat_Handler, }, { MethodName: "GetRegion", Handler: _PD_GetRegion_Handler, }, { MethodName: "GetPrevRegion", Handler: _PD_GetPrevRegion_Handler, }, { MethodName: "GetRegionByID", Handler: _PD_GetRegionByID_Handler, }, { MethodName: "ScanRegions", Handler: _PD_ScanRegions_Handler, }, { MethodName: "AskSplit", Handler: _PD_AskSplit_Handler, }, { MethodName: "ReportSplit", Handler: _PD_ReportSplit_Handler, }, { MethodName: "AskBatchSplit", Handler: _PD_AskBatchSplit_Handler, }, { MethodName: "ReportBatchSplit", Handler: _PD_ReportBatchSplit_Handler, }, { MethodName: "GetClusterConfig", Handler: _PD_GetClusterConfig_Handler, }, { MethodName: "PutClusterConfig", Handler: _PD_PutClusterConfig_Handler, }, { MethodName: "ScatterRegion", Handler: _PD_ScatterRegion_Handler, }, { MethodName: "GetGCSafePoint", Handler: _PD_GetGCSafePoint_Handler, }, { MethodName: "UpdateGCSafePoint", Handler: _PD_UpdateGCSafePoint_Handler, }, { MethodName: "UpdateServiceGCSafePoint", Handler: _PD_UpdateServiceGCSafePoint_Handler, }, { MethodName: "GetOperator", Handler: _PD_GetOperator_Handler, }, { MethodName: "SyncMaxTS", Handler: _PD_SyncMaxTS_Handler, }, { MethodName: "SplitRegions", Handler: _PD_SplitRegions_Handler, }, { MethodName: "SplitAndScatterRegions", Handler: _PD_SplitAndScatterRegions_Handler, }, { MethodName: "GetDCLocationInfo", Handler: _PD_GetDCLocationInfo_Handler, }, { MethodName: "StoreGlobalConfig", Handler: _PD_StoreGlobalConfig_Handler, }, { MethodName: "LoadGlobalConfig", Handler: _PD_LoadGlobalConfig_Handler, }, { MethodName: "ReportMinResolvedTS", Handler: _PD_ReportMinResolvedTS_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "Tso", Handler: _PD_Tso_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "RegionHeartbeat", Handler: _PD_RegionHeartbeat_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "SyncRegions", Handler: _PD_SyncRegions_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "WatchGlobalConfig", Handler: _PD_WatchGlobalConfig_Handler, ServerStreams: true, }, { StreamName: "ReportBuckets", Handler: _PD_ReportBuckets_Handler, ClientStreams: true, }, }, Metadata: "pdpb.proto", } func (m *WatchGlobalConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WatchGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *WatchGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WatchGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Changes) > 0 { for _, msg := range m.Changes { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreGlobalConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Changes) > 0 { for _, msg := range m.Changes { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Error.Size())) n1, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LoadGlobalConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LoadGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Names) > 0 { for _, s := range m.Names { dAtA[i] = 0xa i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *LoadGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *LoadGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Items) > 0 { for _, msg := range m.Items { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GlobalConfigItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GlobalConfigItem) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.Error != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Error.Size())) n2, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RequestHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) } if m.SenderId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SenderId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResponseHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) } if m.Error != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Error.Size())) n3, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Error) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Type != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Type)) } if len(m.Message) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TsoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n4, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.Count != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) } if len(m.DcLocation) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) i += copy(dAtA[i:], m.DcLocation) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Timestamp) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Physical != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Physical)) } if m.Logical != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Logical)) } if m.SuffixBits != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SuffixBits)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TsoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n5, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.Count != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) } if m.Timestamp != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp.Size())) n6, err := m.Timestamp.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BootstrapRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BootstrapRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n7, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.Store != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size())) n8, err := m.Store.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.Region != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n9, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BootstrapResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n10, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) n11, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IsBootstrappedRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IsBootstrappedRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n12, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IsBootstrappedResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IsBootstrappedResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n13, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.Bootstrapped { dAtA[i] = 0x10 i++ if m.Bootstrapped { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AllocIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AllocIDRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n14, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AllocIDResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AllocIDResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n15, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.Id != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Id)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetStoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetStoreRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n16, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if m.StoreId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetStoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetStoreResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n17, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if m.Store != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size())) n18, err := m.Store.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.Stats != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Stats.Size())) n19, err := m.Stats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutStoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutStoreRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n20, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } if m.Store != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size())) n21, err := m.Store.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutStoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n22, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) n23, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllStoresRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllStoresRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n24, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n24 } if m.ExcludeTombstoneStores { dAtA[i] = 0x10 i++ if m.ExcludeTombstoneStores { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetAllStoresResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetAllStoresResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n25, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } if len(m.Stores) > 0 { for _, msg := range m.Stores { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRegionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRegionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n26, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } if len(m.RegionKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.RegionKey))) i += copy(dAtA[i:], m.RegionKey) } if m.NeedBuckets { dAtA[i] = 0x18 i++ if m.NeedBuckets { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRegionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRegionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n27, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } if m.Region != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n28, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n28 } if m.Leader != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size())) n29, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n29 } if len(m.DownPeers) > 0 { for _, msg := range m.DownPeers { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PendingPeers) > 0 { for _, msg := range m.PendingPeers { dAtA[i] = 0x32 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Buckets != nil { dAtA[i] = 0x3a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Buckets.Size())) n30, err := m.Buckets.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n30 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetRegionByIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRegionByIDRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n31, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n31 } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if m.NeedBuckets { dAtA[i] = 0x18 i++ if m.NeedBuckets { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanRegionsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanRegionsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n32, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n32 } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if m.Limit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Limit)) } if len(m.EndKey) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Region) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Region) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n33, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n33 } if m.Leader != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size())) n34, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n34 } if len(m.DownPeers) > 0 { for _, msg := range m.DownPeers { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PendingPeers) > 0 { for _, msg := range m.PendingPeers { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScanRegionsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScanRegionsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n35, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n35 } if len(m.RegionMetas) > 0 { for _, msg := range m.RegionMetas { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Leaders) > 0 { for _, msg := range m.Leaders { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetClusterConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n36, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n36 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetClusterConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n37, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n37 } if m.Cluster != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Cluster.Size())) n38, err := m.Cluster.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n38 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutClusterConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n39, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n39 } if m.Cluster != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Cluster.Size())) n40, err := m.Cluster.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n40 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutClusterConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n41, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n41 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Member) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Member) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Name) > 0 { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) i += copy(dAtA[i:], m.Name) } if m.MemberId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MemberId)) } if len(m.PeerUrls) > 0 { for _, s := range m.PeerUrls { dAtA[i] = 0x1a i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if len(m.ClientUrls) > 0 { for _, s := range m.ClientUrls { dAtA[i] = 0x22 i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if m.LeaderPriority != 0 { dAtA[i] = 0x28 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.LeaderPriority)) } if len(m.DeployPath) > 0 { dAtA[i] = 0x32 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.DeployPath))) i += copy(dAtA[i:], m.DeployPath) } if len(m.BinaryVersion) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.BinaryVersion))) i += copy(dAtA[i:], m.BinaryVersion) } if len(m.GitHash) > 0 { dAtA[i] = 0x42 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.GitHash))) i += copy(dAtA[i:], m.GitHash) } if len(m.DcLocation) > 0 { dAtA[i] = 0x4a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) i += copy(dAtA[i:], m.DcLocation) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMembersRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMembersRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n42, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n42 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetMembersResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetMembersResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n43, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n43 } if len(m.Members) > 0 { for _, msg := range m.Members { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Leader != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size())) n44, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n44 } if m.EtcdLeader != nil { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.EtcdLeader.Size())) n45, err := m.EtcdLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n45 } if len(m.TsoAllocatorLeaders) > 0 { for k, _ := range m.TsoAllocatorLeaders { dAtA[i] = 0x2a i++ v := m.TsoAllocatorLeaders[k] msgSize := 0 if v != nil { msgSize = v.Size() msgSize += 1 + sovPdpb(uint64(msgSize)) } mapSize := 1 + len(k) + sovPdpb(uint64(len(k))) + msgSize i = encodeVarintPdpb(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(len(k))) i += copy(dAtA[i:], k) if v != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(v.Size())) n46, err := v.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n46 } } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PeerStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PeerStats) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Peer != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size())) n47, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n47 } if m.DownSeconds != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.DownSeconds)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionHeartbeatRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n48, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n48 } if m.Region != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n49, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n49 } if m.Leader != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size())) n50, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n50 } if len(m.DownPeers) > 0 { for _, msg := range m.DownPeers { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PendingPeers) > 0 { for _, msg := range m.PendingPeers { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.BytesWritten != 0 { dAtA[i] = 0x30 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) } if m.BytesRead != 0 { dAtA[i] = 0x38 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) } if m.KeysWritten != 0 { dAtA[i] = 0x40 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) } if m.KeysRead != 0 { dAtA[i] = 0x48 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) } if m.ApproximateSize != 0 { dAtA[i] = 0x50 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateSize)) } if m.Interval != nil { dAtA[i] = 0x62 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Interval.Size())) n51, err := m.Interval.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n51 } if m.ApproximateKeys != 0 { dAtA[i] = 0x68 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKeys)) } if m.Term != 0 { dAtA[i] = 0x70 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Term)) } if m.ReplicationStatus != nil { dAtA[i] = 0x7a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) n52, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n52 } if m.QueryStats != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.QueryStats.Size())) n53, err := m.QueryStats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n53 } if m.CpuUsage != 0 { dAtA[i] = 0x88 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.CpuUsage)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeer) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeer) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Peer != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size())) n54, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n54 } if m.ChangeType != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ChangeType)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeerV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeerV2) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Changes) > 0 { for _, msg := range m.Changes { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TransferLeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Peer != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size())) n55, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n55 } if len(m.Peers) > 0 { for _, msg := range m.Peers { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Merge) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Merge) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Target != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Target.Size())) n56, err := m.Target.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n56 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRegion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Policy != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Policy)) } if len(m.Keys) > 0 { for _, b := range m.Keys { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionHeartbeatResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n57, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n57 } if m.ChangePeer != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ChangePeer.Size())) n58, err := m.ChangePeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n58 } if m.TransferLeader != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.TransferLeader.Size())) n59, err := m.TransferLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n59 } if m.RegionId != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if m.RegionEpoch != nil { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionEpoch.Size())) n60, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n60 } if m.TargetPeer != nil { dAtA[i] = 0x32 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.TargetPeer.Size())) n61, err := m.TargetPeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n61 } if m.Merge != nil { dAtA[i] = 0x3a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Merge.Size())) n62, err := m.Merge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n62 } if m.SplitRegion != nil { dAtA[i] = 0x42 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SplitRegion.Size())) n63, err := m.SplitRegion.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n63 } if m.ChangePeerV2 != nil { dAtA[i] = 0x4a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ChangePeerV2.Size())) n64, err := m.ChangePeerV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n64 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AskSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n65, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n65 } if m.Region != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n66, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n66 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AskSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n67, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n67 } if m.NewRegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { dAtA69 := make([]byte, len(m.NewPeerIds)*10) var j68 int for _, num := range m.NewPeerIds { for num >= 1<<7 { dAtA69[j68] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j68++ } dAtA69[j68] = uint8(num) j68++ } dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(j68)) i += copy(dAtA[i:], dAtA69[:j68]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n70, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n70 } if m.Left != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Left.Size())) n71, err := m.Left.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n71 } if m.Right != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Right.Size())) n72, err := m.Right.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n72 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n73, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n73 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AskBatchSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AskBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n74, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n74 } if m.Region != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n75, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n75 } if m.SplitCount != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SplitCount)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitID) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.NewRegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { dAtA77 := make([]byte, len(m.NewPeerIds)*10) var j76 int for _, num := range m.NewPeerIds { for num >= 1<<7 { dAtA77[j76] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j76++ } dAtA77[j76] = uint8(num) j76++ } dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(j76)) i += copy(dAtA[i:], dAtA77[:j76]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AskBatchSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AskBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n78, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n78 } if len(m.Ids) > 0 { for _, msg := range m.Ids { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportBatchSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n79, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n79 } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportBatchSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n80, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n80 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TimeInterval) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TimeInterval) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTimestamp != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StartTimestamp)) } if m.EndTimestamp != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.EndTimestamp)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RecordPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RecordPair) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.Value != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Value)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PeerStat) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PeerStat) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if m.ReadKeys != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReadKeys)) } if m.ReadBytes != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReadBytes)) } if m.QueryStats != nil { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.QueryStats.Size())) n81, err := m.QueryStats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n81 } if m.WrittenKeys != 0 { dAtA[i] = 0x28 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenKeys)) } if m.WrittenBytes != 0 { dAtA[i] = 0x30 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenBytes)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreStats) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StoreId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) } if m.Capacity != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Capacity)) } if m.Available != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Available)) } if m.RegionCount != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionCount)) } if m.SendingSnapCount != 0 { dAtA[i] = 0x28 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SendingSnapCount)) } if m.ReceivingSnapCount != 0 { dAtA[i] = 0x30 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReceivingSnapCount)) } if m.StartTime != 0 { dAtA[i] = 0x38 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StartTime)) } if m.ApplyingSnapCount != 0 { dAtA[i] = 0x40 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ApplyingSnapCount)) } if m.IsBusy { dAtA[i] = 0x48 i++ if m.IsBusy { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.UsedSize != 0 { dAtA[i] = 0x50 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.UsedSize)) } if m.BytesWritten != 0 { dAtA[i] = 0x58 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) } if m.KeysWritten != 0 { dAtA[i] = 0x60 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) } if m.BytesRead != 0 { dAtA[i] = 0x68 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) } if m.KeysRead != 0 { dAtA[i] = 0x70 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) } if m.Interval != nil { dAtA[i] = 0x7a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Interval.Size())) n82, err := m.Interval.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n82 } if len(m.CpuUsages) > 0 { for _, msg := range m.CpuUsages { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.ReadIoRates) > 0 { for _, msg := range m.ReadIoRates { dAtA[i] = 0x8a i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.WriteIoRates) > 0 { for _, msg := range m.WriteIoRates { dAtA[i] = 0x92 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.OpLatencies) > 0 { for _, msg := range m.OpLatencies { dAtA[i] = 0x9a i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.PeerStats) > 0 { for _, msg := range m.PeerStats { dAtA[i] = 0xa2 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.QueryStats != nil { dAtA[i] = 0xaa i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.QueryStats.Size())) n83, err := m.QueryStats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n83 } if m.SlowScore != 0 { dAtA[i] = 0xb0 i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SlowScore)) } if len(m.DamagedRegionsId) > 0 { dAtA85 := make([]byte, len(m.DamagedRegionsId)*10) var j84 int for _, num := range m.DamagedRegionsId { for num >= 1<<7 { dAtA85[j84] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j84++ } dAtA85[j84] = uint8(num) j84++ } dAtA[i] = 0xba i++ dAtA[i] = 0x1 i++ i = encodeVarintPdpb(dAtA, i, uint64(j84)) i += copy(dAtA[i:], dAtA85[:j84]) } if m.IsApplyBusy { dAtA[i] = 0xc0 i++ dAtA[i] = 0x1 i++ if m.IsApplyBusy { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PeerReport) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PeerReport) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RaftState != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RaftState.Size())) n86, err := m.RaftState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n86 } if m.RegionState != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionState.Size())) n87, err := m.RegionState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n87 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreReport) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreReport) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.PeerReports) > 0 { for _, msg := range m.PeerReports { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreHeartbeatRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n88, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n88 } if m.Stats != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Stats.Size())) n89, err := m.Stats.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n89 } if m.StoreReport != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StoreReport.Size())) n90, err := m.StoreReport.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n90 } if m.DrAutosyncStatus != nil { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.DrAutosyncStatus.Size())) n91, err := m.DrAutosyncStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n91 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RecoveryPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RecoveryPlan) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Creates) > 0 { for _, msg := range m.Creates { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Updates) > 0 { for _, msg := range m.Updates { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Deletes) > 0 { dAtA93 := make([]byte, len(m.Deletes)*10) var j92 int for _, num := range m.Deletes { for num >= 1<<7 { dAtA93[j92] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j92++ } dAtA93[j92] = uint8(num) j92++ } dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(j92)) i += copy(dAtA[i:], dAtA93[:j92]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreHeartbeatResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n94, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n94 } if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) n95, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n95 } if len(m.ClusterVersion) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.ClusterVersion))) i += copy(dAtA[i:], m.ClusterVersion) } if m.RequireDetailedReport { dAtA[i] = 0x20 i++ if m.RequireDetailedReport { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.Plan != nil { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Plan.Size())) n96, err := m.Plan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n96 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScatterRegionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n97, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n97 } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if m.Region != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size())) n98, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n98 } if m.Leader != nil { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size())) n99, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n99 } if len(m.Group) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) i += copy(dAtA[i:], m.Group) } if len(m.RegionsId) > 0 { dAtA101 := make([]byte, len(m.RegionsId)*10) var j100 int for _, num := range m.RegionsId { for num >= 1<<7 { dAtA101[j100] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j100++ } dAtA101[j100] = uint8(num) j100++ } dAtA[i] = 0x32 i++ i = encodeVarintPdpb(dAtA, i, uint64(j100)) i += copy(dAtA[i:], dAtA101[:j100]) } if m.RetryLimit != 0 { dAtA[i] = 0x38 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ScatterRegionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n102, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n102 } if m.FinishedPercentage != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetGCSafePointRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n103, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n103 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetGCSafePointResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n104, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n104 } if m.SafePoint != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateGCSafePointRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n105, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n105 } if m.SafePoint != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateGCSafePointResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n106, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n106 } if m.NewSafePoint != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateServiceGCSafePointRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateServiceGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n107, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n107 } if len(m.ServiceId) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) i += copy(dAtA[i:], m.ServiceId) } if m.TTL != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) } if m.SafePoint != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *UpdateServiceGCSafePointResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateServiceGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n108, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n108 } if len(m.ServiceId) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) i += copy(dAtA[i:], m.ServiceId) } if m.TTL != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) } if m.MinSafePoint != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MinSafePoint)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionStat) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionStat) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.BytesWritten != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) } if m.BytesRead != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) } if m.KeysWritten != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) } if m.KeysRead != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SyncRegionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SyncRegionRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n109, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n109 } if m.Member != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Member.Size())) n110, err := m.Member.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n110 } if m.StartIndex != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SyncRegionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SyncRegionResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n111, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n111 } if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.StartIndex != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) } if len(m.RegionStats) > 0 { for _, msg := range m.RegionStats { dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.RegionLeaders) > 0 { for _, msg := range m.RegionLeaders { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Buckets) > 0 { for _, msg := range m.Buckets { dAtA[i] = 0x32 i++ i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetOperatorRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetOperatorRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n112, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n112 } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetOperatorResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetOperatorResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n113, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n113 } if m.RegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } if len(m.Desc) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Desc))) i += copy(dAtA[i:], m.Desc) } if m.Status != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Status)) } if len(m.Kind) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Kind))) i += copy(dAtA[i:], m.Kind) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SyncMaxTSRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SyncMaxTSRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n114, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n114 } if m.MaxTs != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MaxTs.Size())) n115, err := m.MaxTs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n115 } if m.SkipCheck { dAtA[i] = 0x18 i++ if m.SkipCheck { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SyncMaxTSResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SyncMaxTSResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n116, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n116 } if m.MaxLocalTs != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MaxLocalTs.Size())) n117, err := m.MaxLocalTs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n117 } if len(m.SyncedDcs) > 0 { for _, s := range m.SyncedDcs { dAtA[i] = 0x1a i++ l = len(s) for l >= 1<<7 { dAtA[i] = uint8(uint64(l)&0x7f | 0x80) l >>= 7 i++ } dAtA[i] = uint8(l) i++ i += copy(dAtA[i:], s) } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRegionsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRegionsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n118, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n118 } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if m.RetryLimit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRegionsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRegionsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n119, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n119 } if m.FinishedPercentage != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) } if len(m.RegionsId) > 0 { dAtA121 := make([]byte, len(m.RegionsId)*10) var j120 int for _, num := range m.RegionsId { for num >= 1<<7 { dAtA121[j120] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j120++ } dAtA121[j120] = uint8(num) j120++ } dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(j120)) i += copy(dAtA[i:], dAtA121[:j120]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitAndScatterRegionsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitAndScatterRegionsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n122, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n122 } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(b))) i += copy(dAtA[i:], b) } } if len(m.Group) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) i += copy(dAtA[i:], m.Group) } if m.RetryLimit != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitAndScatterRegionsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitAndScatterRegionsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n123, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n123 } if m.SplitFinishedPercentage != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SplitFinishedPercentage)) } if m.ScatterFinishedPercentage != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ScatterFinishedPercentage)) } if len(m.RegionsId) > 0 { dAtA125 := make([]byte, len(m.RegionsId)*10) var j124 int for _, num := range m.RegionsId { for num >= 1<<7 { dAtA125[j124] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j124++ } dAtA125[j124] = uint8(num) j124++ } dAtA[i] = 0x22 i++ i = encodeVarintPdpb(dAtA, i, uint64(j124)) i += copy(dAtA[i:], dAtA125[:j124]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetDCLocationInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetDCLocationInfoRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n126, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n126 } if len(m.DcLocation) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) i += copy(dAtA[i:], m.DcLocation) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetDCLocationInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetDCLocationInfoResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n127, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n127 } if m.Suffix != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Suffix)) } if m.MaxTs != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MaxTs.Size())) n128, err := m.MaxTs.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n128 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *QueryStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *QueryStats) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.GC != 0 { dAtA[i] = 0x8 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.GC)) } if m.Get != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Get)) } if m.Scan != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Scan)) } if m.Coprocessor != 0 { dAtA[i] = 0x20 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Coprocessor)) } if m.Delete != 0 { dAtA[i] = 0x28 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Delete)) } if m.DeleteRange != 0 { dAtA[i] = 0x30 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.DeleteRange)) } if m.Put != 0 { dAtA[i] = 0x38 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Put)) } if m.Prewrite != 0 { dAtA[i] = 0x40 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Prewrite)) } if m.AcquirePessimisticLock != 0 { dAtA[i] = 0x48 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.AcquirePessimisticLock)) } if m.Commit != 0 { dAtA[i] = 0x50 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Commit)) } if m.Rollback != 0 { dAtA[i] = 0x58 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Rollback)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportBucketsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportBucketsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n129, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n129 } if m.RegionEpoch != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionEpoch.Size())) n130, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n130 } if m.Buckets != nil { dAtA[i] = 0x1a i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Buckets.Size())) n131, err := m.Buckets.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n131 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportBucketsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportBucketsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n132, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n132 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportMinResolvedTsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportMinResolvedTsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n133, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n133 } if m.StoreId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) } if m.MinResolvedTs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.MinResolvedTs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReportMinResolvedTsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReportMinResolvedTsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) n134, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n134 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *WatchGlobalConfigRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *WatchGlobalConfigResponse) Size() (n int) { var l int _ = l if len(m.Changes) > 0 { for _, e := range m.Changes { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreGlobalConfigRequest) Size() (n int) { var l int _ = l if len(m.Changes) > 0 { for _, e := range m.Changes { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreGlobalConfigResponse) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LoadGlobalConfigRequest) Size() (n int) { var l int _ = l if len(m.Names) > 0 { for _, s := range m.Names { l = len(s) n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *LoadGlobalConfigResponse) Size() (n int) { var l int _ = l if len(m.Items) > 0 { for _, e := range m.Items { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GlobalConfigItem) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RequestHeader) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovPdpb(uint64(m.ClusterId)) } if m.SenderId != 0 { n += 1 + sovPdpb(uint64(m.SenderId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResponseHeader) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovPdpb(uint64(m.ClusterId)) } if m.Error != nil { l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Error) Size() (n int) { var l int _ = l if m.Type != 0 { n += 1 + sovPdpb(uint64(m.Type)) } l = len(m.Message) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TsoRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Count != 0 { n += 1 + sovPdpb(uint64(m.Count)) } l = len(m.DcLocation) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Timestamp) Size() (n int) { var l int _ = l if m.Physical != 0 { n += 1 + sovPdpb(uint64(m.Physical)) } if m.Logical != 0 { n += 1 + sovPdpb(uint64(m.Logical)) } if m.SuffixBits != 0 { n += 1 + sovPdpb(uint64(m.SuffixBits)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TsoResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Count != 0 { n += 1 + sovPdpb(uint64(m.Count)) } if m.Timestamp != nil { l = m.Timestamp.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BootstrapRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Store != nil { l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BootstrapResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ReplicationStatus != nil { l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IsBootstrappedRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IsBootstrappedResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Bootstrapped { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AllocIDRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AllocIDResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Id != 0 { n += 1 + sovPdpb(uint64(m.Id)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetStoreRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.StoreId != 0 { n += 1 + sovPdpb(uint64(m.StoreId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetStoreResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Store != nil { l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Stats != nil { l = m.Stats.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutStoreRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Store != nil { l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutStoreResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ReplicationStatus != nil { l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllStoresRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ExcludeTombstoneStores { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetAllStoresResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Stores) > 0 { for _, e := range m.Stores { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRegionRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.RegionKey) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.NeedBuckets { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRegionResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.DownPeers) > 0 { for _, e := range m.DownPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.PendingPeers) > 0 { for _, e := range m.PendingPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.Buckets != nil { l = m.Buckets.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetRegionByIDRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } if m.NeedBuckets { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanRegionsRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.Limit != 0 { n += 1 + sovPdpb(uint64(m.Limit)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Region) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.DownPeers) > 0 { for _, e := range m.DownPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.PendingPeers) > 0 { for _, e := range m.PendingPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScanRegionsResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.RegionMetas) > 0 { for _, e := range m.RegionMetas { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.Leaders) > 0 { for _, e := range m.Leaders { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetClusterConfigRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetClusterConfigResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Cluster != nil { l = m.Cluster.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutClusterConfigRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Cluster != nil { l = m.Cluster.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutClusterConfigResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Member) Size() (n int) { var l int _ = l l = len(m.Name) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.MemberId != 0 { n += 1 + sovPdpb(uint64(m.MemberId)) } if len(m.PeerUrls) > 0 { for _, s := range m.PeerUrls { l = len(s) n += 1 + l + sovPdpb(uint64(l)) } } if len(m.ClientUrls) > 0 { for _, s := range m.ClientUrls { l = len(s) n += 1 + l + sovPdpb(uint64(l)) } } if m.LeaderPriority != 0 { n += 1 + sovPdpb(uint64(m.LeaderPriority)) } l = len(m.DeployPath) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } l = len(m.BinaryVersion) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } l = len(m.GitHash) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } l = len(m.DcLocation) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMembersRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetMembersResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Members) > 0 { for _, e := range m.Members { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.EtcdLeader != nil { l = m.EtcdLeader.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.TsoAllocatorLeaders) > 0 { for k, v := range m.TsoAllocatorLeaders { _ = k _ = v l = 0 if v != nil { l = v.Size() l += 1 + sovPdpb(uint64(l)) } mapEntrySize := 1 + len(k) + sovPdpb(uint64(len(k))) + l n += mapEntrySize + 1 + sovPdpb(uint64(mapEntrySize)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PeerStats) Size() (n int) { var l int _ = l if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.DownSeconds != 0 { n += 1 + sovPdpb(uint64(m.DownSeconds)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionHeartbeatRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.DownPeers) > 0 { for _, e := range m.DownPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.PendingPeers) > 0 { for _, e := range m.PendingPeers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.BytesWritten != 0 { n += 1 + sovPdpb(uint64(m.BytesWritten)) } if m.BytesRead != 0 { n += 1 + sovPdpb(uint64(m.BytesRead)) } if m.KeysWritten != 0 { n += 1 + sovPdpb(uint64(m.KeysWritten)) } if m.KeysRead != 0 { n += 1 + sovPdpb(uint64(m.KeysRead)) } if m.ApproximateSize != 0 { n += 1 + sovPdpb(uint64(m.ApproximateSize)) } if m.Interval != nil { l = m.Interval.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ApproximateKeys != 0 { n += 1 + sovPdpb(uint64(m.ApproximateKeys)) } if m.Term != 0 { n += 1 + sovPdpb(uint64(m.Term)) } if m.ReplicationStatus != nil { l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.QueryStats != nil { l = m.QueryStats.Size() n += 2 + l + sovPdpb(uint64(l)) } if m.CpuUsage != 0 { n += 2 + sovPdpb(uint64(m.CpuUsage)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeer) Size() (n int) { var l int _ = l if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ChangeType != 0 { n += 1 + sovPdpb(uint64(m.ChangeType)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeerV2) Size() (n int) { var l int _ = l if len(m.Changes) > 0 { for _, e := range m.Changes { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TransferLeader) Size() (n int) { var l int _ = l if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Peers) > 0 { for _, e := range m.Peers { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Merge) Size() (n int) { var l int _ = l if m.Target != nil { l = m.Target.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRegion) Size() (n int) { var l int _ = l if m.Policy != 0 { n += 1 + sovPdpb(uint64(m.Policy)) } if len(m.Keys) > 0 { for _, b := range m.Keys { l = len(b) n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionHeartbeatResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ChangePeer != nil { l = m.ChangePeer.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.TransferLeader != nil { l = m.TransferLeader.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.TargetPeer != nil { l = m.TargetPeer.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Merge != nil { l = m.Merge.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SplitRegion != nil { l = m.SplitRegion.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ChangePeerV2 != nil { l = m.ChangePeerV2.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AskSplitRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AskSplitResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.NewRegionId != 0 { n += 1 + sovPdpb(uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { l = 0 for _, e := range m.NewPeerIds { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportSplitRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Left != nil { l = m.Left.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Right != nil { l = m.Right.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportSplitResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AskBatchSplitRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SplitCount != 0 { n += 1 + sovPdpb(uint64(m.SplitCount)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitID) Size() (n int) { var l int _ = l if m.NewRegionId != 0 { n += 1 + sovPdpb(uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { l = 0 for _, e := range m.NewPeerIds { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AskBatchSplitResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Ids) > 0 { for _, e := range m.Ids { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportBatchSplitRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportBatchSplitResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TimeInterval) Size() (n int) { var l int _ = l if m.StartTimestamp != 0 { n += 1 + sovPdpb(uint64(m.StartTimestamp)) } if m.EndTimestamp != 0 { n += 1 + sovPdpb(uint64(m.EndTimestamp)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RecordPair) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.Value != 0 { n += 1 + sovPdpb(uint64(m.Value)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PeerStat) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } if m.ReadKeys != 0 { n += 1 + sovPdpb(uint64(m.ReadKeys)) } if m.ReadBytes != 0 { n += 1 + sovPdpb(uint64(m.ReadBytes)) } if m.QueryStats != nil { l = m.QueryStats.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.WrittenKeys != 0 { n += 1 + sovPdpb(uint64(m.WrittenKeys)) } if m.WrittenBytes != 0 { n += 1 + sovPdpb(uint64(m.WrittenBytes)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreStats) Size() (n int) { var l int _ = l if m.StoreId != 0 { n += 1 + sovPdpb(uint64(m.StoreId)) } if m.Capacity != 0 { n += 1 + sovPdpb(uint64(m.Capacity)) } if m.Available != 0 { n += 1 + sovPdpb(uint64(m.Available)) } if m.RegionCount != 0 { n += 1 + sovPdpb(uint64(m.RegionCount)) } if m.SendingSnapCount != 0 { n += 1 + sovPdpb(uint64(m.SendingSnapCount)) } if m.ReceivingSnapCount != 0 { n += 1 + sovPdpb(uint64(m.ReceivingSnapCount)) } if m.StartTime != 0 { n += 1 + sovPdpb(uint64(m.StartTime)) } if m.ApplyingSnapCount != 0 { n += 1 + sovPdpb(uint64(m.ApplyingSnapCount)) } if m.IsBusy { n += 2 } if m.UsedSize != 0 { n += 1 + sovPdpb(uint64(m.UsedSize)) } if m.BytesWritten != 0 { n += 1 + sovPdpb(uint64(m.BytesWritten)) } if m.KeysWritten != 0 { n += 1 + sovPdpb(uint64(m.KeysWritten)) } if m.BytesRead != 0 { n += 1 + sovPdpb(uint64(m.BytesRead)) } if m.KeysRead != 0 { n += 1 + sovPdpb(uint64(m.KeysRead)) } if m.Interval != nil { l = m.Interval.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.CpuUsages) > 0 { for _, e := range m.CpuUsages { l = e.Size() n += 2 + l + sovPdpb(uint64(l)) } } if len(m.ReadIoRates) > 0 { for _, e := range m.ReadIoRates { l = e.Size() n += 2 + l + sovPdpb(uint64(l)) } } if len(m.WriteIoRates) > 0 { for _, e := range m.WriteIoRates { l = e.Size() n += 2 + l + sovPdpb(uint64(l)) } } if len(m.OpLatencies) > 0 { for _, e := range m.OpLatencies { l = e.Size() n += 2 + l + sovPdpb(uint64(l)) } } if len(m.PeerStats) > 0 { for _, e := range m.PeerStats { l = e.Size() n += 2 + l + sovPdpb(uint64(l)) } } if m.QueryStats != nil { l = m.QueryStats.Size() n += 2 + l + sovPdpb(uint64(l)) } if m.SlowScore != 0 { n += 2 + sovPdpb(uint64(m.SlowScore)) } if len(m.DamagedRegionsId) > 0 { l = 0 for _, e := range m.DamagedRegionsId { l += sovPdpb(uint64(e)) } n += 2 + sovPdpb(uint64(l)) + l } if m.IsApplyBusy { n += 3 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PeerReport) Size() (n int) { var l int _ = l if m.RaftState != nil { l = m.RaftState.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionState != nil { l = m.RegionState.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreReport) Size() (n int) { var l int _ = l if len(m.PeerReports) > 0 { for _, e := range m.PeerReports { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreHeartbeatRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Stats != nil { l = m.Stats.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.StoreReport != nil { l = m.StoreReport.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.DrAutosyncStatus != nil { l = m.DrAutosyncStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RecoveryPlan) Size() (n int) { var l int _ = l if len(m.Creates) > 0 { for _, e := range m.Creates { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.Updates) > 0 { for _, e := range m.Updates { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.Deletes) > 0 { l = 0 for _, e := range m.Deletes { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreHeartbeatResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.ReplicationStatus != nil { l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.ClusterVersion) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.RequireDetailedReport { n += 2 } if m.Plan != nil { l = m.Plan.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScatterRegionRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.Group) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if len(m.RegionsId) > 0 { l = 0 for _, e := range m.RegionsId { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.RetryLimit != 0 { n += 1 + sovPdpb(uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ScatterRegionResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.FinishedPercentage != 0 { n += 1 + sovPdpb(uint64(m.FinishedPercentage)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetGCSafePointRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetGCSafePointResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SafePoint != 0 { n += 1 + sovPdpb(uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateGCSafePointRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SafePoint != 0 { n += 1 + sovPdpb(uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateGCSafePointResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.NewSafePoint != 0 { n += 1 + sovPdpb(uint64(m.NewSafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateServiceGCSafePointRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.ServiceId) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.TTL != 0 { n += 1 + sovPdpb(uint64(m.TTL)) } if m.SafePoint != 0 { n += 1 + sovPdpb(uint64(m.SafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *UpdateServiceGCSafePointResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.ServiceId) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.TTL != 0 { n += 1 + sovPdpb(uint64(m.TTL)) } if m.MinSafePoint != 0 { n += 1 + sovPdpb(uint64(m.MinSafePoint)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionStat) Size() (n int) { var l int _ = l if m.BytesWritten != 0 { n += 1 + sovPdpb(uint64(m.BytesWritten)) } if m.BytesRead != 0 { n += 1 + sovPdpb(uint64(m.BytesRead)) } if m.KeysWritten != 0 { n += 1 + sovPdpb(uint64(m.KeysWritten)) } if m.KeysRead != 0 { n += 1 + sovPdpb(uint64(m.KeysRead)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SyncRegionRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Member != nil { l = m.Member.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.StartIndex != 0 { n += 1 + sovPdpb(uint64(m.StartIndex)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SyncRegionResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.StartIndex != 0 { n += 1 + sovPdpb(uint64(m.StartIndex)) } if len(m.RegionStats) > 0 { for _, e := range m.RegionStats { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.RegionLeaders) > 0 { for _, e := range m.RegionLeaders { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if len(m.Buckets) > 0 { for _, e := range m.Buckets { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetOperatorRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetOperatorResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } l = len(m.Desc) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.Status != 0 { n += 1 + sovPdpb(uint64(m.Status)) } l = len(m.Kind) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SyncMaxTSRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.MaxTs != nil { l = m.MaxTs.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SkipCheck { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SyncMaxTSResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.MaxLocalTs != nil { l = m.MaxLocalTs.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.SyncedDcs) > 0 { for _, s := range m.SyncedDcs { l = len(s) n += 1 + l + sovPdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRegionsRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { l = len(b) n += 1 + l + sovPdpb(uint64(l)) } } if m.RetryLimit != 0 { n += 1 + sovPdpb(uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRegionsResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.FinishedPercentage != 0 { n += 1 + sovPdpb(uint64(m.FinishedPercentage)) } if len(m.RegionsId) > 0 { l = 0 for _, e := range m.RegionsId { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitAndScatterRegionsRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if len(m.SplitKeys) > 0 { for _, b := range m.SplitKeys { l = len(b) n += 1 + l + sovPdpb(uint64(l)) } } l = len(m.Group) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.RetryLimit != 0 { n += 1 + sovPdpb(uint64(m.RetryLimit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitAndScatterRegionsResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.SplitFinishedPercentage != 0 { n += 1 + sovPdpb(uint64(m.SplitFinishedPercentage)) } if m.ScatterFinishedPercentage != 0 { n += 1 + sovPdpb(uint64(m.ScatterFinishedPercentage)) } if len(m.RegionsId) > 0 { l = 0 for _, e := range m.RegionsId { l += sovPdpb(uint64(e)) } n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetDCLocationInfoRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } l = len(m.DcLocation) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetDCLocationInfoResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Suffix != 0 { n += 1 + sovPdpb(uint64(m.Suffix)) } if m.MaxTs != nil { l = m.MaxTs.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *QueryStats) Size() (n int) { var l int _ = l if m.GC != 0 { n += 1 + sovPdpb(uint64(m.GC)) } if m.Get != 0 { n += 1 + sovPdpb(uint64(m.Get)) } if m.Scan != 0 { n += 1 + sovPdpb(uint64(m.Scan)) } if m.Coprocessor != 0 { n += 1 + sovPdpb(uint64(m.Coprocessor)) } if m.Delete != 0 { n += 1 + sovPdpb(uint64(m.Delete)) } if m.DeleteRange != 0 { n += 1 + sovPdpb(uint64(m.DeleteRange)) } if m.Put != 0 { n += 1 + sovPdpb(uint64(m.Put)) } if m.Prewrite != 0 { n += 1 + sovPdpb(uint64(m.Prewrite)) } if m.AcquirePessimisticLock != 0 { n += 1 + sovPdpb(uint64(m.AcquirePessimisticLock)) } if m.Commit != 0 { n += 1 + sovPdpb(uint64(m.Commit)) } if m.Rollback != 0 { n += 1 + sovPdpb(uint64(m.Rollback)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportBucketsRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.Buckets != nil { l = m.Buckets.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportBucketsResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportMinResolvedTsRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.StoreId != 0 { n += 1 + sovPdpb(uint64(m.StoreId)) } if m.MinResolvedTs != 0 { n += 1 + sovPdpb(uint64(m.MinResolvedTs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReportMinResolvedTsResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovPdpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozPdpb(x uint64) (n int) { return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *WatchGlobalConfigRequest) 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 ErrIntOverflowPdpb } 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: WatchGlobalConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WatchGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *WatchGlobalConfigResponse) 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 ErrIntOverflowPdpb } 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: WatchGlobalConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WatchGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Changes = append(m.Changes, &GlobalConfigItem{}) if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreGlobalConfigRequest) 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 ErrIntOverflowPdpb } 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: StoreGlobalConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Changes = append(m.Changes, &GlobalConfigItem{}) if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreGlobalConfigResponse) 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 ErrIntOverflowPdpb } 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: StoreGlobalConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *LoadGlobalConfigRequest) 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 ErrIntOverflowPdpb } 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: LoadGlobalConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LoadGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Names = append(m.Names, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *LoadGlobalConfigResponse) 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 ErrIntOverflowPdpb } 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: LoadGlobalConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LoadGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Items = append(m.Items, &GlobalConfigItem{}) if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GlobalConfigItem) 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 ErrIntOverflowPdpb } 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: GlobalConfigItem: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GlobalConfigItem: 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 ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RequestHeader) 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 ErrIntOverflowPdpb } 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: RequestHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SenderId", wireType) } m.SenderId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SenderId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ResponseHeader) 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 ErrIntOverflowPdpb } 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: ResponseHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *Error) 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 ErrIntOverflowPdpb } 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: Error: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= (ErrorType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *TsoRequest) 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 ErrIntOverflowPdpb } 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: TsoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TsoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) } m.Count = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Count |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.DcLocation = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *Timestamp) 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 ErrIntOverflowPdpb } 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: Timestamp: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType) } m.Physical = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Physical |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType) } m.Logical = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Logical |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SuffixBits", wireType) } m.SuffixBits = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SuffixBits |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *TsoResponse) 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 ErrIntOverflowPdpb } 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: TsoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TsoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) } m.Count = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Count |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 3: 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Timestamp == nil { m.Timestamp = &Timestamp{} } if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *BootstrapRequest) 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 ErrIntOverflowPdpb } 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: BootstrapRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Store == nil { m.Store = &metapb.Store{} } if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *BootstrapResponse) 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 ErrIntOverflowPdpb } 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: BootstrapResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReplicationStatus == nil { m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *IsBootstrappedRequest) 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 ErrIntOverflowPdpb } 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: IsBootstrappedRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IsBootstrappedRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *IsBootstrappedResponse) 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 ErrIntOverflowPdpb } 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: IsBootstrappedResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IsBootstrappedResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Bootstrapped", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.Bootstrapped = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AllocIDRequest) 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 ErrIntOverflowPdpb } 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: AllocIDRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AllocIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AllocIDResponse) 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 ErrIntOverflowPdpb } 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: AllocIDResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AllocIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetStoreRequest) 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 ErrIntOverflowPdpb } 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: GetStoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetStoreResponse) 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 ErrIntOverflowPdpb } 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: GetStoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Store == nil { m.Store = &metapb.Store{} } if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Stats == nil { m.Stats = &StoreStats{} } if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PutStoreRequest) 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 ErrIntOverflowPdpb } 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: PutStoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Store == nil { m.Store = &metapb.Store{} } if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PutStoreResponse) 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 ErrIntOverflowPdpb } 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: PutStoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReplicationStatus == nil { m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetAllStoresRequest) 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 ErrIntOverflowPdpb } 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: GetAllStoresRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllStoresRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExcludeTombstoneStores", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ExcludeTombstoneStores = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetAllStoresResponse) 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 ErrIntOverflowPdpb } 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: GetAllStoresResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetAllStoresResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stores", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Stores = append(m.Stores, &metapb.Store{}) if err := m.Stores[len(m.Stores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetRegionRequest) 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 ErrIntOverflowPdpb } 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: GetRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.RegionKey = append(m.RegionKey[:0], dAtA[iNdEx:postIndex]...) if m.RegionKey == nil { m.RegionKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NeedBuckets = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetRegionResponse) 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 ErrIntOverflowPdpb } 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: GetRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.DownPeers = append(m.DownPeers, &PeerStats{}) if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Buckets == nil { m.Buckets = &metapb.Buckets{} } if err := m.Buckets.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetRegionByIDRequest) 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 ErrIntOverflowPdpb } 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: GetRegionByIDRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetRegionByIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NeedBuckets = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ScanRegionsRequest) 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 ErrIntOverflowPdpb } 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: ScanRegionsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanRegionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *Region) 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 ErrIntOverflowPdpb } 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: Region: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Region: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.DownPeers = append(m.DownPeers, &PeerStats{}) if err := m.DownPeers[len(m.DownPeers)-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 PendingPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ScanRegionsResponse) 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 ErrIntOverflowPdpb } 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: ScanRegionsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScanRegionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionMetas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RegionMetas = append(m.RegionMetas, &metapb.Region{}) if err := m.RegionMetas[len(m.RegionMetas)-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 Leaders", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Leaders = append(m.Leaders, &metapb.Peer{}) if err := m.Leaders[len(m.Leaders)-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 Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &Region{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetClusterConfigRequest) 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 ErrIntOverflowPdpb } 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: GetClusterConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetClusterConfigResponse) 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 ErrIntOverflowPdpb } 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: GetClusterConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Cluster == nil { m.Cluster = &metapb.Cluster{} } if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PutClusterConfigRequest) 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 ErrIntOverflowPdpb } 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: PutClusterConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Cluster == nil { m.Cluster = &metapb.Cluster{} } if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PutClusterConfigResponse) 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 ErrIntOverflowPdpb } 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: PutClusterConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *Member) 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 ErrIntOverflowPdpb } 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: Member: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Member: 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 ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen 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 MemberId", wireType) } m.MemberId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MemberId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PeerUrls", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.PeerUrls = append(m.PeerUrls, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClientUrls", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ClientUrls = append(m.ClientUrls, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LeaderPriority", wireType) } m.LeaderPriority = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LeaderPriority |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DeployPath", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.DeployPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.BinaryVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GitHash", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.GitHash = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.DcLocation = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetMembersRequest) 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 ErrIntOverflowPdpb } 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: GetMembersRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMembersRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetMembersResponse) 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 ErrIntOverflowPdpb } 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: GetMembersResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetMembersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Members = append(m.Members, &Member{}) if err := m.Members[len(m.Members)-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 Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &Member{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EtcdLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.EtcdLeader == nil { m.EtcdLeader = &Member{} } if err := m.EtcdLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TsoAllocatorLeaders", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TsoAllocatorLeaders == nil { m.TsoAllocatorLeaders = make(map[string]*Member) } var mapkey string var mapvalue *Member for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postStringIndexmapkey := iNdEx + intStringLenmapkey 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapmsglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if mapmsglen < 0 { return ErrInvalidLengthPdpb } postmsgIndex := iNdEx + mapmsglen if mapmsglen < 0 { return ErrInvalidLengthPdpb } if postmsgIndex > l { return io.ErrUnexpectedEOF } mapvalue = &Member{} if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { return err } iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.TsoAllocatorLeaders[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PeerStats) 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 ErrIntOverflowPdpb } 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: PeerStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PeerStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DownSeconds", wireType) } m.DownSeconds = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DownSeconds |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RegionHeartbeatRequest) 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 ErrIntOverflowPdpb } 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: RegionHeartbeatRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.DownPeers = append(m.DownPeers, &PeerStats{}) if err := m.DownPeers[len(m.DownPeers)-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 PendingPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) } m.BytesWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) } m.BytesRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) } m.KeysWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) } m.KeysRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApproximateSize", wireType) } m.ApproximateSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApproximateSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Interval == nil { m.Interval = &TimeInterval{} } if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKeys", wireType) } m.ApproximateKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApproximateKeys |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReplicationStatus == nil { m.ReplicationStatus = &replication_modepb.RegionReplicationStatus{} } if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.QueryStats == nil { m.QueryStats = &QueryStats{} } if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 17: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuUsage", wireType) } m.CpuUsage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuUsage |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ChangePeer) 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 ErrIntOverflowPdpb } 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: ChangePeer: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeer: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) } m.ChangeType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ChangeType |= (eraftpb.ConfChangeType(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ChangePeerV2) 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 ErrIntOverflowPdpb } 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: ChangePeerV2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeerV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Changes = append(m.Changes, &ChangePeer{}) if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *TransferLeader) 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 ErrIntOverflowPdpb } 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: TransferLeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TransferLeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Peers = append(m.Peers, &metapb.Peer{}) if err := m.Peers[len(m.Peers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *Merge) 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 ErrIntOverflowPdpb } 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: Merge: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Target == nil { m.Target = &metapb.Region{} } if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitRegion) 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 ErrIntOverflowPdpb } 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: SplitRegion: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRegion: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType) } m.Policy = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Policy |= (CheckPolicy(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RegionHeartbeatResponse) 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 ErrIntOverflowPdpb } 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: RegionHeartbeatResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeer == nil { m.ChangePeer = &ChangePeer{} } if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TransferLeader == nil { m.TransferLeader = &TransferLeader{} } if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TargetPeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TargetPeer == nil { m.TargetPeer = &metapb.Peer{} } if err := m.TargetPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Merge == nil { m.Merge = &Merge{} } if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitRegion", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.SplitRegion == nil { m.SplitRegion = &SplitRegion{} } if err := m.SplitRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeerV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeerV2 == nil { m.ChangePeerV2 = &ChangePeerV2{} } if err := m.ChangePeerV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AskSplitRequest) 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 ErrIntOverflowPdpb } 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: AskSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AskSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AskSplitResponse) 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 ErrIntOverflowPdpb } 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: AskSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AskSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) } m.NewRegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NewRegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportSplitRequest) 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 ErrIntOverflowPdpb } 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: ReportSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Left == nil { m.Left = &metapb.Region{} } if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Right == nil { m.Right = &metapb.Region{} } if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportSplitResponse) 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 ErrIntOverflowPdpb } 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: ReportSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AskBatchSplitRequest) 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 ErrIntOverflowPdpb } 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: AskBatchSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AskBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SplitCount", wireType) } m.SplitCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SplitCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitID) 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 ErrIntOverflowPdpb } 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: SplitID: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) } m.NewRegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NewRegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *AskBatchSplitResponse) 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 ErrIntOverflowPdpb } 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: AskBatchSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AskBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Ids = append(m.Ids, &SplitID{}) if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportBatchSplitRequest) 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 ErrIntOverflowPdpb } 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: ReportBatchSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &metapb.Region{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportBatchSplitResponse) 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 ErrIntOverflowPdpb } 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: ReportBatchSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *TimeInterval) 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 ErrIntOverflowPdpb } 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: TimeInterval: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TimeInterval: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTimestamp", wireType) } m.StartTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTimestamp |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndTimestamp", wireType) } m.EndTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndTimestamp |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RecordPair) 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 ErrIntOverflowPdpb } 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: RecordPair: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RecordPair: 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 ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } m.Value = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Value |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PeerStat) 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 ErrIntOverflowPdpb } 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: PeerStat: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PeerStat: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadKeys", wireType) } m.ReadKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadKeys |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType) } m.ReadBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.QueryStats == nil { m.QueryStats = &QueryStats{} } if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WrittenKeys", wireType) } m.WrittenKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WrittenKeys |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WrittenBytes", wireType) } m.WrittenBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WrittenBytes |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreStats) 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 ErrIntOverflowPdpb } 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: StoreStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType) } m.Capacity = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Capacity |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType) } m.Available = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Available |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionCount", wireType) } m.RegionCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SendingSnapCount", wireType) } m.SendingSnapCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SendingSnapCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReceivingSnapCount", wireType) } m.ReceivingSnapCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReceivingSnapCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) } m.StartTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTime |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApplyingSnapCount", wireType) } m.ApplyingSnapCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApplyingSnapCount |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsBusy", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsBusy = bool(v != 0) case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UsedSize", wireType) } m.UsedSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.UsedSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) } m.BytesWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) } m.KeysWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) } m.BytesRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) } m.KeysRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Interval == nil { m.Interval = &TimeInterval{} } if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CpuUsages", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.CpuUsages = append(m.CpuUsages, &RecordPair{}) if err := m.CpuUsages[len(m.CpuUsages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 17: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIoRates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.ReadIoRates = append(m.ReadIoRates, &RecordPair{}) if err := m.ReadIoRates[len(m.ReadIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WriteIoRates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.WriteIoRates = append(m.WriteIoRates, &RecordPair{}) if err := m.WriteIoRates[len(m.WriteIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field OpLatencies", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.OpLatencies = append(m.OpLatencies, &RecordPair{}) if err := m.OpLatencies[len(m.OpLatencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 20: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PeerStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.PeerStats = append(m.PeerStats, &PeerStat{}) if err := m.PeerStats[len(m.PeerStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 21: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.QueryStats == nil { m.QueryStats = &QueryStats{} } if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 22: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SlowScore", wireType) } m.SlowScore = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SlowScore |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 23: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.DamagedRegionsId = append(m.DamagedRegionsId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.DamagedRegionsId = append(m.DamagedRegionsId, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field DamagedRegionsId", wireType) } case 24: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsApplyBusy", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsApplyBusy = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *PeerReport) 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 ErrIntOverflowPdpb } 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: PeerReport: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PeerReport: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RaftState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RaftState == nil { m.RaftState = &raft_serverpb.RaftLocalState{} } if err := m.RaftState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionState == nil { m.RegionState = &raft_serverpb.RegionLocalState{} } if err := m.RegionState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreReport) 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 ErrIntOverflowPdpb } 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: StoreReport: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreReport: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PeerReports", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.PeerReports = append(m.PeerReports, &PeerReport{}) if err := m.PeerReports[len(m.PeerReports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreHeartbeatRequest) 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 ErrIntOverflowPdpb } 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: StoreHeartbeatRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Stats == nil { m.Stats = &StoreStats{} } if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StoreReport", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StoreReport == nil { m.StoreReport = &StoreReport{} } if err := m.StoreReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DrAutosyncStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DrAutosyncStatus == nil { m.DrAutosyncStatus = &replication_modepb.StoreDRAutoSyncStatus{} } if err := m.DrAutosyncStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RecoveryPlan) 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 ErrIntOverflowPdpb } 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: RecoveryPlan: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RecoveryPlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Creates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Creates = append(m.Creates, &metapb.Region{}) if err := m.Creates[len(m.Creates)-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 Updates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Updates = append(m.Updates, &metapb.Region{}) if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Deletes = append(m.Deletes, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.Deletes = append(m.Deletes, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Deletes", wireType) } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *StoreHeartbeatResponse) 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 ErrIntOverflowPdpb } 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: StoreHeartbeatResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReplicationStatus == nil { m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.ClusterVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RequireDetailedReport", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RequireDetailedReport = bool(v != 0) case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Plan == nil { m.Plan = &RecoveryPlan{} } if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ScatterRegionRequest) 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 ErrIntOverflowPdpb } 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: ScatterRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScatterRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Group = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RegionsId", wireType) } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RetryLimit", wireType) } m.RetryLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RetryLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ScatterRegionResponse) 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 ErrIntOverflowPdpb } 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: ScatterRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ScatterRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FinishedPercentage", wireType) } m.FinishedPercentage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FinishedPercentage |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetGCSafePointRequest) 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 ErrIntOverflowPdpb } 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: GetGCSafePointRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetGCSafePointResponse) 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 ErrIntOverflowPdpb } 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: GetGCSafePointResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *UpdateGCSafePointRequest) 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 ErrIntOverflowPdpb } 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: UpdateGCSafePointRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *UpdateGCSafePointResponse) 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 ErrIntOverflowPdpb } 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: UpdateGCSafePointResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NewSafePoint", wireType) } m.NewSafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NewSafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *UpdateServiceGCSafePointRequest) 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 ErrIntOverflowPdpb } 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: UpdateServiceGCSafePointRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) if m.ServiceId == nil { m.ServiceId = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) } m.TTL = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TTL |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *UpdateServiceGCSafePointResponse) 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 ErrIntOverflowPdpb } 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: UpdateServiceGCSafePointResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) if m.ServiceId == nil { m.ServiceId = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) } m.TTL = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TTL |= (int64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinSafePoint", wireType) } m.MinSafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinSafePoint |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *RegionStat) 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 ErrIntOverflowPdpb } 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: RegionStat: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionStat: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) } m.BytesWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) } m.BytesRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BytesRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) } m.KeysWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysWritten |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) } m.KeysRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.KeysRead |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SyncRegionRequest) 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 ErrIntOverflowPdpb } 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: SyncRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SyncRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Member == nil { m.Member = &Member{} } if err := m.Member.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartIndex", wireType) } m.StartIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SyncRegionResponse) 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 ErrIntOverflowPdpb } 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: SyncRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SyncRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &metapb.Region{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartIndex", wireType) } m.StartIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RegionStats = append(m.RegionStats, &RegionStat{}) if err := m.RegionStats[len(m.RegionStats)-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 RegionLeaders", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RegionLeaders = append(m.RegionLeaders, &metapb.Peer{}) if err := m.RegionLeaders[len(m.RegionLeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Buckets = append(m.Buckets, &metapb.Buckets{}) if err := m.Buckets[len(m.Buckets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetOperatorRequest) 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 ErrIntOverflowPdpb } 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: GetOperatorRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetOperatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetOperatorResponse) 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 ErrIntOverflowPdpb } 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: GetOperatorResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetOperatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Desc = append(m.Desc[:0], dAtA[iNdEx:postIndex]...) if m.Desc == nil { m.Desc = []byte{} } iNdEx = postIndex 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 ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Status |= (OperatorStatus(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Kind = append(m.Kind[:0], dAtA[iNdEx:postIndex]...) if m.Kind == nil { m.Kind = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SyncMaxTSRequest) 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 ErrIntOverflowPdpb } 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: SyncMaxTSRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SyncMaxTSRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MaxTs == nil { m.MaxTs = &Timestamp{} } if err := m.MaxTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SkipCheck", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SkipCheck = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SyncMaxTSResponse) 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 ErrIntOverflowPdpb } 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: SyncMaxTSResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SyncMaxTSResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MaxLocalTs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MaxLocalTs == nil { m.MaxLocalTs = &Timestamp{} } if err := m.MaxLocalTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SyncedDcs", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.SyncedDcs = append(m.SyncedDcs, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitRegionsRequest) 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 ErrIntOverflowPdpb } 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: SplitRegionsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRegionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitKeys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.SplitKeys = append(m.SplitKeys, make([]byte, postIndex-iNdEx)) copy(m.SplitKeys[len(m.SplitKeys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RetryLimit", wireType) } m.RetryLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RetryLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitRegionsResponse) 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 ErrIntOverflowPdpb } 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: SplitRegionsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRegionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FinishedPercentage", wireType) } m.FinishedPercentage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FinishedPercentage |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RegionsId", wireType) } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitAndScatterRegionsRequest) 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 ErrIntOverflowPdpb } 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: SplitAndScatterRegionsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitAndScatterRegionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitKeys", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.SplitKeys = append(m.SplitKeys, make([]byte, postIndex-iNdEx)) copy(m.SplitKeys[len(m.SplitKeys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Group = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RetryLimit", wireType) } m.RetryLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RetryLimit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *SplitAndScatterRegionsResponse) 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 ErrIntOverflowPdpb } 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: SplitAndScatterRegionsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitAndScatterRegionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SplitFinishedPercentage", wireType) } m.SplitFinishedPercentage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SplitFinishedPercentage |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ScatterFinishedPercentage", wireType) } m.ScatterFinishedPercentage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ScatterFinishedPercentage |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RegionsId = append(m.RegionsId, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RegionsId", wireType) } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetDCLocationInfoRequest) 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 ErrIntOverflowPdpb } 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: GetDCLocationInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetDCLocationInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } 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 ErrInvalidLengthPdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.DcLocation = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *GetDCLocationInfoResponse) 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 ErrIntOverflowPdpb } 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: GetDCLocationInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetDCLocationInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Suffix", wireType) } m.Suffix = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Suffix |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MaxTs == nil { m.MaxTs = &Timestamp{} } if err := m.MaxTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *QueryStats) 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 ErrIntOverflowPdpb } 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: QueryStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: QueryStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field GC", wireType) } m.GC = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.GC |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType) } m.Get = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Get |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Scan", wireType) } m.Scan = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Scan |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Coprocessor", wireType) } m.Coprocessor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Coprocessor |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Delete", wireType) } m.Delete = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Delete |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType) } m.DeleteRange = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DeleteRange |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType) } m.Put = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Put |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType) } m.Prewrite = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Prewrite |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AcquirePessimisticLock", wireType) } m.AcquirePessimisticLock = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AcquirePessimisticLock |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Rollback", wireType) } m.Rollback = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Rollback |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportBucketsRequest) 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 ErrIntOverflowPdpb } 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: ReportBucketsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportBucketsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Buckets == nil { m.Buckets = &metapb.Buckets{} } if err := m.Buckets.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportBucketsResponse) 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 ErrIntOverflowPdpb } 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: ReportBucketsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportBucketsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportMinResolvedTsRequest) 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 ErrIntOverflowPdpb } 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: ReportMinResolvedTsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportMinResolvedTsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinResolvedTs", wireType) } m.MinResolvedTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinResolvedTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 *ReportMinResolvedTsResponse) 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 ErrIntOverflowPdpb } 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: ReportMinResolvedTsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReportMinResolvedTsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthPdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthPdpb } 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 skipPdpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPdpb } 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, ErrIntOverflowPdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthPdpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowPdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipPdpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthPdpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowPdpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_pdpb_3495b43081031f06) } var fileDescriptor_pdpb_3495b43081031f06 = []byte{ // 4707 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3c, 0xcb, 0x8e, 0x23, 0x47, 0x72, 0x5d, 0x6c, 0x92, 0x4d, 0x06, 0x1f, 0xcd, 0xce, 0x7e, 0x71, 0x38, 0x3b, 0x0f, 0xd5, 0x8c, 0xc6, 0x92, 0x76, 0xd5, 0x92, 0x46, 0x82, 0x20, 0xc8, 0x5e, 0xc1, 0xec, 0xc7, 0xf4, 0x50, 0xd3, 0x0f, 0xba, 0xc8, 0x91, 0x56, 0xc6, 0xc2, 0x85, 0xea, 0xaa, 0xec, 0xee, 0x72, 0x93, 0x55, 0xa5, 0xaa, 0x62, 0xcf, 0x70, 0xe1, 0x83, 0x1f, 0x80, 0xbd, 0x86, 0x77, 0x0d, 0x03, 0x36, 0x6c, 0x9f, 0x7c, 0x58, 0x3f, 0x2f, 0xbe, 0xf8, 0x60, 0xd8, 0x77, 0x63, 0xe1, 0xe3, 0x1e, 0x7d, 0x32, 0x0c, 0xf9, 0xe4, 0x4f, 0x30, 0xec, 0x83, 0x91, 0x91, 0x99, 0xc5, 0x62, 0xb1, 0x38, 0xdd, 0x53, 0x23, 0x19, 0x7b, 0x6a, 0x66, 0x44, 0x64, 0x64, 0x64, 0x64, 0x44, 0x64, 0x64, 0x64, 0x56, 0x03, 0x78, 0x96, 0x77, 0xb2, 0xe5, 0xf9, 0x6e, 0xe8, 0x92, 0x3c, 0xfb, 0xdd, 0xaa, 0x0e, 0x69, 0x68, 0x48, 0x58, 0xab, 0x46, 0x7d, 0xe3, 0x34, 0x8c, 0x9a, 0xab, 0xac, 0xa5, 0x07, 0xd4, 0xbf, 0xa4, 0x7e, 0x04, 0x6c, 0xfa, 0xd4, 0x1b, 0xd8, 0xa6, 0x11, 0xda, 0xae, 0xa3, 0x0f, 0x5d, 0x8b, 0x46, 0x98, 0xb5, 0x33, 0xf7, 0xcc, 0xc5, 0x9f, 0xef, 0xb0, 0x5f, 0x02, 0xba, 0xec, 0x8f, 0x82, 0x10, 0x7f, 0x72, 0x80, 0xda, 0x82, 0xe6, 0xe7, 0x46, 0x68, 0x9e, 0xef, 0x0f, 0xdc, 0x13, 0x63, 0xb0, 0xe3, 0x3a, 0xa7, 0xf6, 0x99, 0x46, 0xbf, 0x1c, 0xd1, 0x20, 0x54, 0x0f, 0xe1, 0x46, 0x0a, 0x2e, 0xf0, 0x5c, 0x27, 0xa0, 0xe4, 0x5d, 0x58, 0x32, 0xcf, 0x0d, 0xe7, 0x8c, 0x06, 0x4d, 0xe5, 0xee, 0xe2, 0x1b, 0x95, 0x87, 0x1b, 0x5b, 0x38, 0x9f, 0x38, 0x71, 0x27, 0xa4, 0x43, 0x4d, 0x92, 0xa9, 0x07, 0xd0, 0xec, 0x85, 0xae, 0x4f, 0x53, 0x86, 0xca, 0xc0, 0xed, 0x13, 0xb8, 0x91, 0xc2, 0x4d, 0x08, 0xf7, 0x1a, 0x14, 0xa8, 0xef, 0xbb, 0x7e, 0x53, 0xb9, 0xab, 0xbc, 0x51, 0x79, 0x58, 0xe1, 0xcc, 0xf6, 0x18, 0x48, 0xe3, 0x18, 0xf5, 0x1d, 0xd8, 0x3c, 0x70, 0x0d, 0x2b, 0x4d, 0x98, 0x35, 0x28, 0x38, 0xc6, 0x50, 0x88, 0x52, 0xd6, 0x78, 0x43, 0x7d, 0x0c, 0xcd, 0xd9, 0x0e, 0x62, 0xbc, 0xef, 0x40, 0xc1, 0x0e, 0xe9, 0xf0, 0x2a, 0xe1, 0x39, 0x91, 0xaa, 0x43, 0x23, 0x89, 0x22, 0x04, 0xf2, 0x6c, 0x18, 0x14, 0xb8, 0xac, 0xe1, 0x6f, 0x26, 0xc7, 0xa5, 0x31, 0x18, 0xd1, 0x66, 0x0e, 0x81, 0xbc, 0x31, 0x99, 0xdb, 0xe2, 0xdc, 0xb9, 0x3d, 0x81, 0x9a, 0x98, 0xcb, 0x63, 0x6a, 0x58, 0xd4, 0x27, 0xb7, 0x00, 0xcc, 0xc1, 0x28, 0x08, 0xa9, 0xaf, 0xdb, 0x16, 0x8e, 0x91, 0xd7, 0xca, 0x02, 0xd2, 0xb1, 0xc8, 0x4d, 0x28, 0x07, 0xd4, 0xb1, 0x38, 0x36, 0x87, 0xd8, 0x12, 0x07, 0x74, 0x2c, 0x55, 0x83, 0xba, 0x9c, 0xe7, 0xf5, 0xb8, 0x45, 0x02, 0xe6, 0xe6, 0x0a, 0xf8, 0x08, 0x0a, 0xd8, 0x26, 0xf7, 0x20, 0x1f, 0x8e, 0x3d, 0x3e, 0xed, 0xfa, 0xc3, 0xe5, 0x18, 0x69, 0x7f, 0xec, 0x51, 0x0d, 0x91, 0xa4, 0x09, 0x4b, 0x43, 0x1a, 0x04, 0xc6, 0x99, 0xd4, 0x84, 0x6c, 0xaa, 0x1e, 0x40, 0x3f, 0x70, 0xe5, 0xba, 0x7d, 0x1b, 0x8a, 0xe7, 0x28, 0xa1, 0x58, 0xf6, 0x55, 0xce, 0x6e, 0x4a, 0x15, 0x9a, 0x20, 0x61, 0xca, 0x35, 0xdd, 0x91, 0x13, 0x22, 0xcb, 0x9a, 0xc6, 0x1b, 0xe4, 0x0e, 0x54, 0x2c, 0x53, 0x1f, 0xb8, 0xdc, 0xa3, 0x50, 0xc5, 0x65, 0x0d, 0x2c, 0xf3, 0x40, 0x40, 0xd4, 0x13, 0x28, 0xf7, 0xed, 0x21, 0x0d, 0x42, 0x63, 0xe8, 0x91, 0x16, 0x94, 0xbc, 0xf3, 0x71, 0x60, 0x9b, 0xc6, 0x00, 0x87, 0x5c, 0xd4, 0xa2, 0x36, 0x13, 0x7a, 0xe0, 0x9e, 0x21, 0x2a, 0x87, 0x28, 0xd9, 0x64, 0x63, 0x04, 0xa3, 0xd3, 0x53, 0xfb, 0xb9, 0x7e, 0x62, 0x87, 0x01, 0x8e, 0x51, 0xd3, 0x80, 0x83, 0xb6, 0xed, 0x30, 0x50, 0x7f, 0x53, 0x81, 0x0a, 0x4e, 0x2b, 0xb2, 0xae, 0xe9, 0x79, 0xad, 0xc9, 0x79, 0xc5, 0x57, 0xe5, 0x8a, 0x89, 0xbd, 0x0d, 0xe5, 0x50, 0xca, 0x2d, 0x2c, 0x47, 0x68, 0x3b, 0x9a, 0x8e, 0x36, 0xa1, 0x50, 0x7f, 0xa4, 0x40, 0x63, 0xdb, 0x75, 0xc3, 0x20, 0xf4, 0x0d, 0x2f, 0x93, 0x7e, 0xef, 0x41, 0x21, 0x60, 0xfe, 0x29, 0xac, 0xa0, 0xb6, 0x25, 0x62, 0x1b, 0x3a, 0xad, 0xc6, 0x71, 0xe4, 0x01, 0x14, 0x7d, 0x7a, 0x26, 0x35, 0x5d, 0x79, 0x58, 0x97, 0x54, 0x1a, 0x42, 0x35, 0x81, 0x55, 0xff, 0x4c, 0x81, 0x95, 0x98, 0x38, 0x99, 0xf4, 0xd2, 0x07, 0x12, 0x0f, 0x96, 0x41, 0x68, 0x84, 0xa3, 0x40, 0x48, 0xf7, 0xfa, 0x56, 0x4a, 0x1c, 0xd5, 0x26, 0xa0, 0x1e, 0x12, 0x6b, 0x2b, 0x7e, 0x12, 0xa4, 0xee, 0xc2, 0x7a, 0x27, 0x88, 0x44, 0xf3, 0xa8, 0x95, 0x45, 0x59, 0xea, 0xaf, 0xc3, 0x46, 0x92, 0x4b, 0xa6, 0x39, 0xaa, 0x50, 0x3d, 0x89, 0x71, 0xc1, 0xd9, 0x95, 0xb4, 0x29, 0x98, 0xfa, 0x5d, 0xa8, 0xb7, 0x07, 0x03, 0xd7, 0xec, 0xec, 0x66, 0x12, 0xf5, 0x18, 0x96, 0xa3, 0xee, 0x99, 0x64, 0xac, 0x43, 0x2e, 0x8a, 0x32, 0x39, 0xdb, 0x52, 0xbf, 0x80, 0xe5, 0x7d, 0x1a, 0x72, 0xb3, 0xc8, 0x62, 0x68, 0x37, 0xa0, 0x84, 0xc6, 0x34, 0x89, 0x5d, 0x4b, 0xd8, 0xee, 0x58, 0xea, 0x8f, 0x15, 0x68, 0x4c, 0x78, 0x67, 0x92, 0xf6, 0x9a, 0x66, 0x5c, 0x60, 0xe6, 0x14, 0x08, 0x2b, 0x6e, 0x70, 0x8e, 0x48, 0xc2, 0xcc, 0x24, 0xd0, 0x38, 0x5a, 0x35, 0x61, 0xb9, 0x3b, 0x7a, 0x85, 0xa9, 0x5e, 0x47, 0x18, 0xf5, 0x4f, 0x15, 0x68, 0x4c, 0x46, 0xf9, 0x39, 0x72, 0x95, 0xdf, 0x80, 0xd5, 0x7d, 0x1a, 0xb6, 0x07, 0x03, 0x14, 0x2d, 0xc8, 0xa4, 0x81, 0x8f, 0xa0, 0x49, 0x9f, 0x9b, 0x83, 0x91, 0x45, 0xf5, 0xd0, 0x1d, 0x9e, 0x04, 0xa1, 0xeb, 0x50, 0x1d, 0xe7, 0x1d, 0x08, 0x63, 0xdf, 0x10, 0xf8, 0xbe, 0x44, 0xf3, 0xd1, 0xd4, 0x0b, 0x58, 0x9b, 0x1e, 0x3d, 0x93, 0x66, 0x5e, 0x87, 0x62, 0x34, 0xda, 0xe2, 0xec, 0x12, 0x08, 0xa4, 0xfa, 0x5b, 0xdc, 0xf0, 0x44, 0x14, 0xcb, 0x32, 0xd1, 0x5b, 0x00, 0x3c, 0xf6, 0xe9, 0x17, 0x74, 0x8c, 0x53, 0xab, 0x6a, 0x65, 0x0e, 0x79, 0x42, 0xc7, 0xe4, 0x35, 0xa8, 0x3a, 0x94, 0x5a, 0xfa, 0xc9, 0xc8, 0xbc, 0xa0, 0xc2, 0xf0, 0x4a, 0x5a, 0x85, 0xc1, 0xb6, 0x39, 0x48, 0xfd, 0xcb, 0x1c, 0xac, 0xc4, 0x64, 0xc8, 0x34, 0xdd, 0x49, 0x7c, 0xce, 0xbd, 0x28, 0x3e, 0x93, 0xfb, 0x50, 0x1c, 0x70, 0xae, 0xdc, 0x03, 0xaa, 0x92, 0xae, 0x4b, 0x19, 0x37, 0x8e, 0x23, 0x5b, 0x00, 0x96, 0xfb, 0xcc, 0xd1, 0x3d, 0x4a, 0xfd, 0xa0, 0x59, 0x40, 0x05, 0x8a, 0x4d, 0x88, 0xd1, 0x71, 0x57, 0x29, 0x33, 0x12, 0xd6, 0x0c, 0xc8, 0x7b, 0x50, 0xf3, 0xa8, 0x63, 0xd9, 0xce, 0x99, 0xe8, 0x52, 0xc4, 0x2e, 0xd3, 0xcc, 0xab, 0x82, 0x84, 0x77, 0x79, 0x13, 0x96, 0xa4, 0x4a, 0x96, 0xc4, 0x26, 0x27, 0x88, 0x85, 0x5a, 0x34, 0x89, 0xff, 0x34, 0x5f, 0xca, 0x37, 0x0a, 0xea, 0xef, 0x28, 0x68, 0x17, 0x7c, 0x3e, 0xdb, 0xe3, 0x6c, 0x41, 0x91, 0x25, 0x50, 0x62, 0xb5, 0x26, 0x09, 0x14, 0x07, 0x60, 0x3e, 0x74, 0xe5, 0x5a, 0xfd, 0x58, 0x01, 0xd2, 0x33, 0x0d, 0x87, 0x8b, 0x11, 0x64, 0x95, 0x21, 0x08, 0x0d, 0x3f, 0x8c, 0x19, 0x4c, 0x09, 0x01, 0xcc, 0x5e, 0xd6, 0xa0, 0x30, 0xb0, 0x87, 0x76, 0x88, 0x83, 0x17, 0x34, 0xde, 0x20, 0x9b, 0xb0, 0x44, 0x1d, 0x0b, 0x3b, 0xe4, 0xb1, 0x43, 0x91, 0x3a, 0xd6, 0x13, 0x3a, 0x56, 0xff, 0x59, 0x81, 0x22, 0x97, 0x25, 0x66, 0x02, 0xca, 0x35, 0x4d, 0x20, 0x77, 0x6d, 0x13, 0x58, 0x7c, 0x79, 0x13, 0xc8, 0x5f, 0x65, 0x02, 0xea, 0x4f, 0x15, 0x58, 0x9d, 0xd2, 0x65, 0x26, 0xcb, 0x7f, 0x0f, 0xaa, 0x62, 0x45, 0xd9, 0x48, 0xd2, 0xdd, 0x93, 0x93, 0xaf, 0x70, 0x9a, 0x43, 0x46, 0x42, 0x1e, 0xc0, 0x12, 0x9f, 0xa5, 0x9c, 0xd8, 0xb4, 0x94, 0x12, 0xc9, 0xe8, 0x78, 0xb7, 0xc9, 0x6c, 0x84, 0x24, 0xc8, 0x53, 0x22, 0xd5, 0x47, 0xb0, 0xb9, 0x4f, 0xc3, 0x1d, 0x9e, 0x57, 0x4f, 0x9f, 0x50, 0x5e, 0x6a, 0xc7, 0x0e, 0xa0, 0x39, 0xcb, 0x27, 0x93, 0x52, 0xde, 0x84, 0x25, 0x91, 0xe6, 0x8b, 0x45, 0x8e, 0xbc, 0x4b, 0x70, 0xd7, 0x24, 0x5e, 0xfd, 0x12, 0x36, 0xbb, 0xa3, 0x57, 0x17, 0xfe, 0x65, 0x86, 0x7c, 0x0c, 0xcd, 0xd9, 0x21, 0xb3, 0xcc, 0x53, 0xfd, 0xab, 0x1c, 0x14, 0x0f, 0xe9, 0xf0, 0x84, 0xfa, 0xa9, 0xe7, 0xb2, 0x9b, 0x50, 0x1e, 0x22, 0x36, 0xe6, 0xed, 0x1c, 0xc0, 0xcf, 0x52, 0xcc, 0x52, 0xf5, 0x91, 0x3f, 0xe0, 0x76, 0x50, 0xd6, 0x4a, 0x0c, 0xf0, 0xd4, 0x1f, 0x04, 0x2c, 0xf5, 0x37, 0x07, 0x36, 0x75, 0x42, 0x8e, 0xce, 0x23, 0x1a, 0x38, 0x08, 0x09, 0x7e, 0x01, 0x96, 0xb9, 0x99, 0xe8, 0x9e, 0x6f, 0xbb, 0xbe, 0x1d, 0x8e, 0x9b, 0x05, 0xf4, 0xd8, 0x3a, 0x07, 0x77, 0x05, 0x14, 0x0f, 0x2a, 0xd4, 0x1b, 0xb8, 0x63, 0xdd, 0x33, 0xc2, 0xf3, 0x66, 0x51, 0x1c, 0x54, 0x10, 0xd4, 0x35, 0xc2, 0x73, 0xf2, 0x3a, 0xd4, 0x4f, 0x6c, 0xc7, 0xf0, 0xc7, 0xfa, 0x25, 0xf5, 0x03, 0xe6, 0xbf, 0x4b, 0x48, 0x53, 0xe3, 0xd0, 0xcf, 0x38, 0x90, 0x65, 0x4f, 0x67, 0x76, 0xa8, 0x9f, 0x1b, 0xc1, 0x79, 0xb3, 0xc4, 0x0f, 0x57, 0x67, 0x76, 0xf8, 0xd8, 0x08, 0xce, 0x93, 0x67, 0xa1, 0xf2, 0xcc, 0x59, 0xe8, 0x97, 0x71, 0x83, 0xe1, 0x8a, 0xca, 0x14, 0xb3, 0xd4, 0xff, 0xcd, 0x01, 0x89, 0xb3, 0xc8, 0xb8, 0x49, 0x2d, 0x71, 0xed, 0x4b, 0x2f, 0x15, 0xfe, 0xc4, 0xb9, 0x6a, 0x12, 0x99, 0xb2, 0x49, 0xc5, 0xc9, 0x64, 0x84, 0x7a, 0x1b, 0x2a, 0x34, 0x34, 0x2d, 0x5d, 0x90, 0xe6, 0x53, 0x48, 0x81, 0x11, 0x1c, 0x70, 0x72, 0x0a, 0xeb, 0x61, 0xe0, 0xea, 0xc6, 0x00, 0xf5, 0xe4, 0xfa, 0xba, 0x0c, 0x01, 0x7c, 0x7b, 0x7b, 0x4f, 0x54, 0x02, 0x66, 0xe6, 0xb8, 0xd5, 0x0f, 0xdc, 0xb6, 0xec, 0xc4, 0x79, 0x05, 0x7b, 0x4e, 0xe8, 0x8f, 0xb5, 0xd5, 0x70, 0x16, 0xd3, 0xea, 0x43, 0x73, 0x5e, 0x07, 0xd2, 0x80, 0x45, 0x16, 0xc1, 0xb9, 0x85, 0xb2, 0x9f, 0x44, 0x8d, 0x17, 0x0e, 0x92, 0xd2, 0x73, 0xd4, 0xc7, 0xb9, 0x8f, 0x14, 0xb5, 0x0b, 0xe5, 0x28, 0xea, 0x92, 0xbb, 0x90, 0x67, 0x76, 0x2a, 0x54, 0x3e, 0x1d, 0xbb, 0x10, 0xc3, 0x36, 0x32, 0x0c, 0xde, 0x01, 0x35, 0x5d, 0xc7, 0x0a, 0x84, 0xe9, 0x57, 0x18, 0xac, 0xc7, 0x41, 0xea, 0x4f, 0x0b, 0xb0, 0xc1, 0xe3, 0xd8, 0x63, 0x6a, 0xf8, 0xe1, 0x09, 0x35, 0xc2, 0x4c, 0x6e, 0xff, 0x4d, 0x26, 0x1e, 0xf9, 0x97, 0xdf, 0x75, 0x0a, 0x57, 0x26, 0x1e, 0xf7, 0xa0, 0x76, 0x32, 0x0e, 0x69, 0xa0, 0x3f, 0xf3, 0xed, 0x30, 0xa4, 0x0e, 0x7a, 0x64, 0x5e, 0xab, 0x22, 0xf0, 0x73, 0x0e, 0x63, 0x49, 0x1d, 0x27, 0xf2, 0xa9, 0x61, 0xa1, 0x3f, 0xe6, 0xb5, 0x32, 0x42, 0x34, 0x6a, 0x60, 0xa2, 0x70, 0x41, 0xc7, 0x13, 0x16, 0x25, 0xae, 0x5f, 0x06, 0x93, 0x1c, 0x6e, 0x42, 0x19, 0x49, 0x90, 0x41, 0x99, 0x87, 0x1e, 0x06, 0xc0, 0xfe, 0x6f, 0x42, 0xc3, 0xf0, 0x3c, 0xdf, 0x7d, 0x6e, 0x0f, 0x8d, 0x90, 0xea, 0x81, 0xfd, 0x03, 0xda, 0x04, 0xa4, 0x59, 0x8e, 0xc1, 0x7b, 0xf6, 0x0f, 0x28, 0xd9, 0x82, 0x92, 0xed, 0x84, 0xd4, 0xbf, 0x34, 0x06, 0xcd, 0x2a, 0x6a, 0x8e, 0x4c, 0xaa, 0x01, 0x1d, 0x81, 0xd1, 0x22, 0x9a, 0x24, 0x6b, 0x36, 0x64, 0xb3, 0x36, 0xc3, 0xfa, 0x09, 0x1d, 0x07, 0x2c, 0x62, 0x86, 0xd4, 0x1f, 0x36, 0xeb, 0x88, 0xc6, 0xdf, 0xe4, 0x57, 0x53, 0x0f, 0x14, 0xcb, 0x38, 0xf0, 0xb7, 0xd3, 0x0f, 0x14, 0x3c, 0x6b, 0xbd, 0xfa, 0x58, 0x41, 0xde, 0x83, 0xca, 0x97, 0x23, 0xea, 0x8f, 0x75, 0x7e, 0x04, 0x6b, 0xc4, 0x8f, 0x60, 0xbf, 0xc2, 0x10, 0x7c, 0x79, 0xe1, 0xcb, 0xe8, 0x37, 0xd3, 0xa2, 0xe9, 0x8d, 0xf4, 0x11, 0x96, 0x94, 0x56, 0xb8, 0x16, 0x4d, 0x6f, 0xf4, 0x94, 0xb5, 0x3f, 0xcd, 0x97, 0x2a, 0x8d, 0xaa, 0x7a, 0x0e, 0xb0, 0x83, 0x95, 0x46, 0xb6, 0xbc, 0xd7, 0xf0, 0x8d, 0x8f, 0xa0, 0xc2, 0x2b, 0x93, 0x3a, 0xd6, 0xb3, 0x72, 0x58, 0xcf, 0xda, 0xdc, 0x92, 0x25, 0x5c, 0xb6, 0x1d, 0x71, 0x7e, 0x58, 0xd7, 0x02, 0x33, 0xfa, 0xad, 0x7e, 0x0c, 0xd5, 0xc9, 0x48, 0x9f, 0x3d, 0x24, 0x6f, 0x25, 0x4b, 0xa1, 0x62, 0x2e, 0x13, 0xa2, 0x49, 0x11, 0xf4, 0x33, 0xa8, 0xf7, 0x7d, 0xc3, 0x09, 0x4e, 0xa9, 0x08, 0x09, 0xd7, 0x90, 0x54, 0x85, 0x02, 0x37, 0xea, 0x5c, 0x8a, 0x51, 0x73, 0x94, 0xfa, 0x0e, 0x14, 0x0e, 0xa9, 0x7f, 0x86, 0x05, 0x9a, 0xd0, 0xf0, 0xcf, 0x68, 0x38, 0x2f, 0xfb, 0xe3, 0x58, 0xf5, 0x00, 0x2a, 0x3d, 0x6f, 0x60, 0x8b, 0x3c, 0x9a, 0xbc, 0x09, 0x45, 0xcf, 0x1d, 0xd8, 0xe6, 0x58, 0x14, 0xf6, 0x56, 0xe4, 0x14, 0xa8, 0x79, 0xd1, 0x45, 0x84, 0x26, 0x08, 0x98, 0xb9, 0xa0, 0x35, 0x31, 0x69, 0xaa, 0x1a, 0xfe, 0x56, 0x7f, 0xb6, 0x08, 0x9b, 0x33, 0x51, 0x24, 0x63, 0x1a, 0x27, 0x97, 0x05, 0xb5, 0x92, 0x8b, 0x1b, 0x47, 0x4c, 0xa1, 0x62, 0x3d, 0x70, 0xad, 0xbf, 0x0b, 0xcb, 0xa1, 0xd0, 0xa9, 0x3e, 0x15, 0x5b, 0xc4, 0x48, 0xd3, 0x0a, 0xd7, 0xea, 0xe1, 0xf4, 0x02, 0x4c, 0x1d, 0x05, 0xf2, 0x89, 0xa3, 0xc0, 0x87, 0x51, 0x56, 0x49, 0x3d, 0xd7, 0x3c, 0xc7, 0xbd, 0x9d, 0x45, 0xc2, 0x29, 0xa5, 0xee, 0x31, 0x94, 0x4c, 0x2d, 0xb1, 0xc1, 0x36, 0x25, 0xae, 0x68, 0x3e, 0x8d, 0x62, 0xca, 0xe2, 0x02, 0x27, 0xe8, 0xf2, 0x40, 0x5d, 0x18, 0xb2, 0xe5, 0x13, 0x67, 0xa0, 0x8a, 0x8c, 0xff, 0xfe, 0x19, 0xd5, 0x38, 0x86, 0x7c, 0x00, 0xd5, 0x80, 0x2d, 0x98, 0x2e, 0xc2, 0x6c, 0x09, 0x29, 0xc5, 0x3a, 0xc5, 0x96, 0x52, 0xab, 0x04, 0xb1, 0x75, 0xfd, 0x08, 0xea, 0x31, 0x75, 0xea, 0x97, 0x0f, 0x31, 0x06, 0x45, 0xc1, 0x23, 0x6e, 0xc7, 0x5a, 0xd5, 0x8c, 0xb5, 0xd4, 0x53, 0x58, 0x6e, 0x07, 0x17, 0x82, 0xf1, 0x37, 0xb7, 0x21, 0xa8, 0xbf, 0xab, 0x40, 0x63, 0x32, 0x50, 0xc6, 0x22, 0x5a, 0xcd, 0xa1, 0xcf, 0xf4, 0xe4, 0x81, 0xae, 0xe2, 0xd0, 0x67, 0x9a, 0x5c, 0xc8, 0xbb, 0xec, 0x4c, 0xf7, 0x8c, 0x6b, 0xc1, 0xb6, 0x78, 0xa2, 0x97, 0xd7, 0xc0, 0xa1, 0xcf, 0xd8, 0x7c, 0x3b, 0x56, 0xa0, 0xfe, 0x81, 0x02, 0x44, 0xa3, 0x9e, 0xeb, 0x87, 0xd9, 0x27, 0xad, 0x42, 0x7e, 0x40, 0x4f, 0xc3, 0x39, 0x53, 0x46, 0x1c, 0xb9, 0x0f, 0x05, 0xdf, 0x3e, 0x3b, 0x0f, 0xe7, 0x54, 0x50, 0x39, 0x52, 0xdd, 0x81, 0xd5, 0x29, 0x61, 0x32, 0xa5, 0xc5, 0x3f, 0x52, 0x60, 0xad, 0x1d, 0x5c, 0x6c, 0x1b, 0xa1, 0x79, 0xfe, 0x8d, 0xaf, 0x24, 0x96, 0xc9, 0xd1, 0x42, 0x79, 0x35, 0x5b, 0x96, 0xc9, 0x19, 0x68, 0x87, 0x41, 0xd4, 0x63, 0x58, 0x42, 0x29, 0x3a, 0xbb, 0xb3, 0x4b, 0xa6, 0x5c, 0xbd, 0x64, 0xb9, 0x99, 0x25, 0x3b, 0x85, 0xf5, 0xc4, 0xf4, 0x32, 0xd9, 0xcf, 0x1d, 0x58, 0x94, 0xfc, 0x2b, 0x0f, 0x6b, 0x31, 0x8f, 0xea, 0xec, 0x6a, 0x0c, 0xa3, 0x7a, 0x2c, 0xba, 0xb1, 0xc5, 0x78, 0x45, 0x4d, 0xbe, 0x31, 0x39, 0x48, 0xa6, 0x1f, 0x4f, 0xa3, 0xa3, 0xe4, 0x63, 0x68, 0xce, 0x8e, 0x98, 0xc9, 0x06, 0xbe, 0x0f, 0xd5, 0x78, 0x8a, 0xc0, 0x0e, 0x2c, 0xbc, 0xea, 0x30, 0xb9, 0x5d, 0xe0, 0xba, 0xaf, 0x23, 0x78, 0x72, 0x57, 0x72, 0x0f, 0x6a, 0xd4, 0xb1, 0x62, 0x64, 0xdc, 0xab, 0xaa, 0xd4, 0xb1, 0x22, 0x22, 0xf5, 0x03, 0x00, 0x8d, 0x9a, 0xae, 0x6f, 0x75, 0x0d, 0xdb, 0x4f, 0x49, 0x6c, 0xa7, 0x6e, 0xc4, 0xf2, 0x22, 0x95, 0x55, 0xff, 0x5d, 0x81, 0x92, 0xcc, 0xe3, 0xa6, 0xe3, 0xaf, 0x92, 0x88, 0xbf, 0x88, 0x34, 0x2c, 0x5d, 0xec, 0x38, 0x02, 0x69, 0x58, 0x98, 0xb8, 0x60, 0xc9, 0xcd, 0xb0, 0x74, 0x4c, 0xc8, 0xd0, 0xde, 0xf2, 0x1a, 0x92, 0x6f, 0x33, 0x40, 0x32, 0xcf, 0xc8, 0x5f, 0x23, 0xcf, 0x78, 0x0d, 0xaa, 0x22, 0x97, 0xe3, 0x23, 0x16, 0xb8, 0x55, 0x0a, 0x18, 0x0e, 0x7a, 0x0f, 0x6a, 0x92, 0x84, 0x8f, 0x2b, 0xf2, 0x46, 0x01, 0xc4, 0xa1, 0xd5, 0x7f, 0x59, 0x02, 0x98, 0x54, 0x93, 0xa7, 0x2a, 0xde, 0xca, 0x54, 0xc5, 0x9b, 0xb4, 0xa0, 0x64, 0x1a, 0x9e, 0x61, 0xb2, 0x83, 0xa3, 0x98, 0x9f, 0x6c, 0x93, 0x6f, 0x41, 0xd9, 0xb8, 0x34, 0xec, 0x81, 0x71, 0x32, 0xa0, 0x72, 0x7a, 0x11, 0x80, 0xc9, 0x2a, 0xf4, 0xc6, 0xfd, 0x2d, 0x8f, 0xfe, 0x26, 0x76, 0x21, 0x74, 0x38, 0xf2, 0x1d, 0x20, 0x81, 0x48, 0x8b, 0x03, 0xc7, 0xf0, 0x04, 0x61, 0x01, 0x09, 0x1b, 0x02, 0xd3, 0x73, 0x0c, 0x8f, 0x53, 0xbf, 0x0b, 0x6b, 0x3e, 0x35, 0xa9, 0x7d, 0x99, 0xa0, 0x2f, 0x22, 0x3d, 0x89, 0x70, 0x93, 0x1e, 0xb7, 0x00, 0x26, 0xb6, 0x84, 0x7b, 0x57, 0x4d, 0x2b, 0x47, 0x66, 0x44, 0xb6, 0x60, 0xd5, 0xf0, 0xbc, 0xc1, 0x38, 0xc1, 0xaf, 0x84, 0x74, 0x2b, 0x12, 0x35, 0x61, 0xb7, 0x09, 0x4b, 0x76, 0xa0, 0x9f, 0x8c, 0x82, 0x31, 0xee, 0x52, 0x25, 0xad, 0x68, 0x07, 0xdb, 0xa3, 0x60, 0xcc, 0xac, 0x60, 0x14, 0x50, 0x2b, 0x9e, 0x20, 0x97, 0x18, 0x00, 0x33, 0xe3, 0x99, 0x44, 0xbe, 0x92, 0x92, 0xc8, 0x27, 0x33, 0xf5, 0xea, 0x6c, 0xa6, 0x3e, 0x9d, 0xeb, 0xd7, 0x92, 0xb9, 0xfe, 0x54, 0x22, 0x5f, 0x4f, 0x24, 0xf2, 0xf1, 0xec, 0x7c, 0xf9, 0x1a, 0xd9, 0xf9, 0x3b, 0x00, 0x51, 0x3e, 0xcb, 0x32, 0xe0, 0x58, 0xd6, 0x38, 0x71, 0x27, 0xad, 0x2c, 0x53, 0xdc, 0x80, 0x7c, 0x00, 0x35, 0x34, 0x75, 0xdb, 0xd5, 0x7d, 0x83, 0x59, 0xdd, 0xca, 0x9c, 0x3e, 0x15, 0x46, 0xd6, 0x71, 0x35, 0x46, 0x44, 0x3e, 0x84, 0x3a, 0x9b, 0x30, 0x9d, 0x74, 0x23, 0x73, 0xba, 0xa1, 0xf9, 0x52, 0xd9, 0xef, 0x7d, 0xa8, 0xba, 0x9e, 0x3e, 0x30, 0x42, 0xea, 0x98, 0x36, 0x0d, 0x9a, 0xab, 0xf3, 0x06, 0x73, 0xbd, 0x03, 0x49, 0x44, 0xde, 0x06, 0xc0, 0x50, 0xcd, 0xbd, 0x6d, 0x4d, 0xc4, 0xb7, 0xa9, 0x33, 0x9b, 0x86, 0x95, 0x16, 0xee, 0x13, 0x09, 0xef, 0x5c, 0xbf, 0x86, 0x77, 0x32, 0x73, 0x1b, 0xb8, 0xcf, 0xf4, 0xc0, 0x74, 0x7d, 0xda, 0xdc, 0xe0, 0x2b, 0xc4, 0x20, 0x3d, 0x06, 0x60, 0xd6, 0x6e, 0x19, 0x43, 0xe3, 0x8c, 0x5a, 0x62, 0x5f, 0x09, 0x98, 0xbf, 0x6d, 0xe2, 0xae, 0xd1, 0x10, 0x18, 0x51, 0x63, 0xec, 0x58, 0x6c, 0x07, 0xb2, 0x03, 0x1d, 0x8d, 0x90, 0x9b, 0x5c, 0x93, 0x57, 0x79, 0xed, 0xa0, 0xcd, 0x60, 0xcc, 0xee, 0xd4, 0x3f, 0x54, 0x00, 0x30, 0x57, 0xc3, 0x50, 0x4c, 0x7e, 0x09, 0x80, 0x3f, 0xe9, 0x08, 0x8d, 0x90, 0x8a, 0xe0, 0x7b, 0x6b, 0x6b, 0xfa, 0x95, 0x87, 0x66, 0x9c, 0x86, 0x07, 0xae, 0x69, 0x0c, 0x98, 0xc8, 0x54, 0x2b, 0x33, 0x2c, 0xfe, 0x24, 0xdb, 0x91, 0xbf, 0xf2, 0xfe, 0x7c, 0x33, 0xbd, 0x93, 0xec, 0x8f, 0x24, 0x31, 0x0e, 0xc2, 0xa1, 0xb1, 0xa1, 0x6e, 0x43, 0x45, 0x5c, 0x13, 0xa1, 0x40, 0xef, 0x43, 0x15, 0x55, 0xee, 0x63, 0x33, 0x71, 0xfc, 0x98, 0x08, 0xae, 0x55, 0xbc, 0xe8, 0x77, 0xa0, 0xfe, 0x8f, 0x02, 0xeb, 0xc8, 0xe4, 0x55, 0x0f, 0xfc, 0xe2, 0x0a, 0x2d, 0xf7, 0xc2, 0x2b, 0x34, 0xcc, 0x5b, 0x31, 0xf6, 0x71, 0x21, 0x45, 0xd6, 0xb3, 0x12, 0x23, 0x97, 0x42, 0x06, 0xb1, 0x99, 0x7d, 0x0e, 0xc4, 0xf2, 0x75, 0x63, 0x14, 0xba, 0xc1, 0xd8, 0x31, 0xe5, 0xf9, 0x93, 0x87, 0xf0, 0x37, 0xd3, 0xce, 0x9f, 0xc8, 0x69, 0x57, 0x6b, 0x8f, 0x42, 0xb7, 0x37, 0x76, 0x4c, 0x71, 0xfa, 0x6c, 0x58, 0x7e, 0x5b, 0xf0, 0x88, 0xee, 0xb4, 0xaa, 0xcc, 0x80, 0x2f, 0xa9, 0x3f, 0xee, 0x0e, 0x0c, 0x87, 0x6d, 0xc9, 0xa6, 0x4f, 0xd1, 0x37, 0x94, 0xf4, 0x2d, 0x59, 0xa0, 0x19, 0xe5, 0xc8, 0xb3, 0x90, 0x72, 0xce, 0xe6, 0x2d, 0xd0, 0xa4, 0x09, 0x4b, 0x16, 0x1d, 0x50, 0xbe, 0x29, 0x31, 0xeb, 0x93, 0x4d, 0xf5, 0xaf, 0x73, 0xb0, 0x91, 0xd4, 0xfd, 0xcf, 0xcf, 0x85, 0x1f, 0xcb, 0x0d, 0xe4, 0x3b, 0x11, 0x59, 0x83, 0xe4, 0x0f, 0x2a, 0xea, 0x02, 0x2c, 0x8b, 0x90, 0x1f, 0xc2, 0xa6, 0x4f, 0xbf, 0x1c, 0xd9, 0x3e, 0xd5, 0x2d, 0x1a, 0x1a, 0xf6, 0x00, 0x7d, 0x0e, 0xd7, 0x37, 0x8f, 0x6e, 0xb4, 0x2e, 0xd0, 0xbb, 0x02, 0x2b, 0x96, 0xf5, 0x01, 0xe4, 0xbd, 0x81, 0xe1, 0x88, 0x63, 0x14, 0x99, 0x04, 0x14, 0xb9, 0x1e, 0x1a, 0xe2, 0xd5, 0x1f, 0xe6, 0x60, 0xad, 0x67, 0x1a, 0x61, 0xc8, 0xcc, 0x36, 0xf3, 0x95, 0xdc, 0x9d, 0x99, 0x4b, 0x9e, 0xed, 0x5c, 0x53, 0x89, 0x65, 0x17, 0xd7, 0x7c, 0xcd, 0x10, 0x2b, 0x5a, 0xe5, 0x5f, 0x50, 0xb4, 0x5a, 0x83, 0xc2, 0x99, 0xef, 0x8e, 0x3c, 0x9c, 0x5d, 0x59, 0xe3, 0x8d, 0xc9, 0xbd, 0x20, 0x46, 0xa3, 0x22, 0xda, 0x83, 0x10, 0x8b, 0x85, 0xa1, 0x3b, 0x50, 0xf1, 0x69, 0xe8, 0x8f, 0x75, 0x7e, 0xdb, 0xc3, 0x4b, 0x4c, 0x80, 0xa0, 0x03, 0x06, 0x51, 0x2f, 0x61, 0x3d, 0xa1, 0x89, 0x4c, 0x06, 0xf3, 0x0e, 0xac, 0x9e, 0xda, 0x8e, 0x1d, 0x9c, 0x53, 0x4b, 0xf7, 0xa8, 0x6f, 0x52, 0x27, 0x94, 0xcf, 0x73, 0xf2, 0x1a, 0x91, 0xa8, 0x6e, 0x84, 0x51, 0x77, 0x61, 0x7d, 0x9f, 0x86, 0xfb, 0x3b, 0x3d, 0xe3, 0x94, 0x76, 0x5d, 0xdb, 0xc9, 0x14, 0x25, 0x54, 0x0a, 0x1b, 0x49, 0x2e, 0x99, 0xc4, 0x67, 0xa1, 0xdf, 0x38, 0xa5, 0xba, 0xc7, 0x78, 0x08, 0xa9, 0xcb, 0x81, 0x64, 0xaa, 0x9e, 0x42, 0xf3, 0x29, 0x3a, 0xdf, 0x2b, 0xca, 0x7b, 0xd5, 0x38, 0x2e, 0xdc, 0x48, 0x19, 0x27, 0xd3, 0x8c, 0xee, 0x43, 0x9d, 0x9d, 0x6e, 0x66, 0x46, 0x63, 0x67, 0x9e, 0x88, 0xb7, 0xfa, 0x17, 0x0a, 0xdc, 0xe1, 0x23, 0xf6, 0xa8, 0x7f, 0x69, 0x9b, 0x5f, 0xcb, 0x04, 0x39, 0x27, 0xe9, 0x14, 0x55, 0xad, 0x2c, 0x20, 0x1d, 0x8b, 0x65, 0xf0, 0xfd, 0xfe, 0x01, 0xba, 0xc3, 0xa2, 0xc6, 0x7e, 0x26, 0x34, 0x92, 0x4f, 0x6a, 0xe4, 0x6f, 0x15, 0xb8, 0x3b, 0x5f, 0xc0, 0xcc, 0x6b, 0xfd, 0x52, 0x22, 0xde, 0x87, 0xfa, 0xd0, 0x76, 0xf4, 0x19, 0x31, 0xab, 0x43, 0xdb, 0x99, 0xa8, 0xf2, 0x8f, 0x14, 0x76, 0x56, 0x91, 0x7b, 0xe9, 0x6c, 0xda, 0xa8, 0x5c, 0x59, 0xff, 0xcd, 0x5d, 0x55, 0xff, 0x5d, 0xbc, 0xa2, 0xfe, 0x9b, 0x9f, 0x4e, 0x1b, 0xd5, 0xdf, 0x53, 0x60, 0x85, 0xed, 0x56, 0xaf, 0x10, 0xe3, 0xee, 0x43, 0x91, 0x5f, 0x97, 0xa4, 0x5e, 0x1d, 0x08, 0x1c, 0x1e, 0xcd, 0x31, 0x51, 0xb7, 0x1d, 0x8b, 0x3e, 0x17, 0x72, 0xf2, 0xdc, 0xbd, 0xc3, 0x20, 0xea, 0x4f, 0x72, 0x40, 0xe2, 0x92, 0x64, 0x5a, 0xb8, 0x6b, 0x1f, 0x6f, 0xaf, 0x94, 0x87, 0x65, 0x36, 0xb1, 0x64, 0x49, 0x5e, 0x01, 0x34, 0xe2, 0xf7, 0xae, 0x98, 0x50, 0xc6, 0xb2, 0x23, 0x96, 0xb6, 0xd6, 0x45, 0xa7, 0xe9, 0x3b, 0x9d, 0xe9, 0x70, 0x5d, 0xe3, 0x34, 0xe2, 0x46, 0x26, 0xfe, 0x00, 0xa1, 0x28, 0xee, 0x19, 0xe6, 0x3c, 0x40, 0x50, 0x7f, 0x0d, 0xef, 0xbe, 0x8e, 0x3d, 0xea, 0x1b, 0xa1, 0xeb, 0x7f, 0xed, 0xef, 0x0e, 0xd4, 0x7f, 0x54, 0xf0, 0xc1, 0xcd, 0x64, 0x80, 0x4c, 0xab, 0xf0, 0xc2, 0xa7, 0x0d, 0x04, 0xf2, 0x16, 0x0d, 0x4c, 0xd4, 0x78, 0x55, 0xc3, 0xdf, 0x8c, 0x7d, 0x2c, 0xbf, 0xaa, 0x4b, 0xf6, 0x52, 0x0c, 0x91, 0x2e, 0x08, 0x1a, 0x2c, 0xff, 0xda, 0x8e, 0x85, 0x9b, 0x5c, 0x55, 0xc3, 0xdf, 0x58, 0xc3, 0x63, 0xd6, 0x73, 0x68, 0x3c, 0xef, 0xf7, 0xb2, 0xd6, 0x98, 0x86, 0xc6, 0x73, 0x3d, 0x4a, 0x27, 0x67, 0x9e, 0x3a, 0x16, 0x86, 0xc6, 0xf3, 0x3e, 0x3f, 0x02, 0x5c, 0xd8, 0x9e, 0x6e, 0x9e, 0x53, 0xf3, 0x42, 0x3c, 0xcc, 0x28, 0x33, 0x08, 0x56, 0xaa, 0xd5, 0x3f, 0x16, 0x0e, 0x25, 0x04, 0xc9, 0xfa, 0x90, 0x80, 0x89, 0x32, 0x60, 0x29, 0xf8, 0x0b, 0x04, 0x82, 0xa1, 0xf1, 0x1c, 0xd3, 0x74, 0x21, 0xd5, 0xd8, 0x31, 0xa9, 0xa5, 0x5b, 0xa6, 0xbc, 0x43, 0x2e, 0x73, 0xc8, 0xae, 0x19, 0xa8, 0xbf, 0xad, 0xc0, 0x6a, 0xac, 0x42, 0x1b, 0x64, 0x0e, 0xdc, 0x58, 0x5d, 0x8b, 0x15, 0xdf, 0xcb, 0x08, 0xc1, 0xb2, 0x44, 0x22, 0x8f, 0x58, 0x9c, 0xc9, 0x23, 0xfe, 0x44, 0x81, 0xb5, 0x69, 0x21, 0xfe, 0x5f, 0xf2, 0x88, 0x44, 0xfe, 0xb3, 0x98, 0xc8, 0x7f, 0xd4, 0x9f, 0x28, 0x70, 0x0b, 0xc5, 0x6a, 0x3b, 0xd6, 0x54, 0x9e, 0xf3, 0x8d, 0x68, 0x29, 0x4a, 0xd1, 0x16, 0xe3, 0x29, 0x5a, 0x42, 0x77, 0xf9, 0x19, 0xdd, 0xfd, 0x97, 0x02, 0xb7, 0xe7, 0x09, 0x99, 0x49, 0x8b, 0x1f, 0xc3, 0x0d, 0x2e, 0xe6, 0x7c, 0x5d, 0x6e, 0x22, 0xc1, 0xa3, 0x59, 0x85, 0x7e, 0x02, 0x37, 0x03, 0x2e, 0x43, 0x6a, 0x6f, 0xbe, 0xf2, 0x37, 0x04, 0xc9, 0xa3, 0xab, 0x16, 0x24, 0x9f, 0x5c, 0x90, 0x73, 0x7c, 0x7c, 0xb2, 0xbb, 0x23, 0x1f, 0x0d, 0x74, 0x9c, 0x53, 0x37, 0x63, 0xf6, 0x3d, 0xf5, 0x1a, 0x21, 0x37, 0xf3, 0x1a, 0xe1, 0xf7, 0x15, 0xb8, 0x91, 0x32, 0x54, 0x26, 0x85, 0x6e, 0x40, 0x91, 0xbf, 0xc7, 0xc6, 0x71, 0x0a, 0x9a, 0x68, 0xc5, 0xe2, 0xca, 0xe2, 0x8b, 0xe2, 0x8a, 0xfa, 0x4f, 0x39, 0x80, 0x49, 0xd5, 0x81, 0xd4, 0x21, 0xb7, 0xbf, 0x23, 0x32, 0x82, 0xdc, 0xfe, 0x0e, 0xcb, 0x39, 0xf6, 0xa9, 0xcc, 0xd0, 0xd8, 0x4f, 0x16, 0x06, 0x7b, 0xa6, 0x21, 0xb7, 0x7c, 0xfc, 0x4d, 0xee, 0x42, 0x65, 0xc7, 0xf5, 0x7c, 0xd7, 0xa4, 0x41, 0xe0, 0xfa, 0xc2, 0x8e, 0xe2, 0x20, 0x26, 0xe6, 0x2e, 0x1e, 0x05, 0x45, 0x65, 0x51, 0xb4, 0x58, 0x4f, 0xfe, 0x4b, 0x33, 0x9c, 0x33, 0x2a, 0x4a, 0x8a, 0x71, 0x10, 0x93, 0xa0, 0x3b, 0x92, 0xe7, 0x03, 0xf6, 0x93, 0xb4, 0xa0, 0xd4, 0xf5, 0x29, 0xd6, 0x6d, 0xc4, 0xc5, 0x73, 0xd4, 0x26, 0x1f, 0xc2, 0x46, 0xdb, 0xc4, 0x03, 0x58, 0x97, 0x06, 0x81, 0x3d, 0xb4, 0x83, 0xd0, 0x66, 0x8a, 0xbf, 0x10, 0x57, 0xd0, 0x73, 0xb0, 0x4c, 0xbe, 0x1d, 0x77, 0xc8, 0x9c, 0x80, 0x57, 0xd9, 0x44, 0x8b, 0x8d, 0xa5, 0xb9, 0x83, 0xc1, 0x89, 0x61, 0x5e, 0x88, 0xf2, 0x5a, 0xd4, 0x56, 0xff, 0x46, 0x81, 0x35, 0x51, 0xab, 0x16, 0x1b, 0x66, 0x16, 0x6b, 0x49, 0x5e, 0xb4, 0xe5, 0xae, 0x79, 0xd1, 0x16, 0xdb, 0xbe, 0x17, 0x5f, 0xfc, 0x7e, 0x50, 0xdd, 0x83, 0xf5, 0x84, 0x9c, 0x59, 0x2f, 0x55, 0x5a, 0x9c, 0xcf, 0xa1, 0xcd, 0x32, 0x25, 0x77, 0x70, 0x49, 0xad, 0x7e, 0xf0, 0x35, 0x3f, 0x85, 0x26, 0x0f, 0x60, 0x99, 0x25, 0xb5, 0xbe, 0x18, 0x40, 0x9a, 0x70, 0x5e, 0xab, 0x0d, 0xe3, 0xc3, 0xaa, 0x4f, 0xe0, 0x66, 0xaa, 0x34, 0x59, 0xe6, 0xf6, 0xd6, 0x3f, 0x28, 0x50, 0x8e, 0x3e, 0xe6, 0x20, 0x45, 0xc8, 0x1d, 0x3f, 0x69, 0x2c, 0x90, 0x0a, 0x2c, 0x3d, 0x3d, 0x7a, 0x72, 0x74, 0xfc, 0xf9, 0x51, 0x43, 0x21, 0x6b, 0xd0, 0x38, 0x3a, 0xee, 0xeb, 0xdb, 0xc7, 0xc7, 0xfd, 0x5e, 0x5f, 0x6b, 0x77, 0xbb, 0x7b, 0xbb, 0x8d, 0x1c, 0x59, 0x85, 0xe5, 0x5e, 0xff, 0x58, 0xdb, 0xd3, 0xfb, 0xc7, 0x87, 0xdb, 0xbd, 0xfe, 0xf1, 0xd1, 0x5e, 0x63, 0x91, 0x34, 0x61, 0xad, 0x7d, 0xa0, 0xed, 0xb5, 0x77, 0xbf, 0x98, 0x26, 0xcf, 0x33, 0x4c, 0xe7, 0x68, 0xe7, 0xf8, 0xb0, 0xdb, 0xee, 0x77, 0xb6, 0x0f, 0xf6, 0xf4, 0xcf, 0xf6, 0xb4, 0x5e, 0xe7, 0xf8, 0xa8, 0x51, 0x60, 0xec, 0xb5, 0xbd, 0xfd, 0xce, 0xf1, 0x91, 0xce, 0x46, 0x79, 0x74, 0xfc, 0xf4, 0x68, 0xb7, 0x51, 0x24, 0x37, 0x61, 0x73, 0xff, 0xe0, 0x78, 0xbb, 0x7d, 0xa0, 0xef, 0x1c, 0x1f, 0x3d, 0xea, 0xec, 0xc7, 0x90, 0x4b, 0x6f, 0x7d, 0x00, 0x95, 0xd8, 0x3d, 0x35, 0x29, 0x41, 0xbe, 0xb7, 0xd3, 0x3e, 0x6a, 0x2c, 0x90, 0x65, 0xa8, 0xb4, 0xbb, 0x5d, 0xed, 0xf8, 0x7b, 0x9d, 0xc3, 0x76, 0x7f, 0xaf, 0xa1, 0x10, 0x80, 0xe2, 0xd3, 0xde, 0xde, 0x93, 0xbd, 0x2f, 0x1a, 0xb9, 0xb7, 0xba, 0x50, 0x9f, 0xce, 0x70, 0xd8, 0x34, 0x7b, 0x4f, 0x77, 0x76, 0xf6, 0x7a, 0x3d, 0x3e, 0xe7, 0x7e, 0xe7, 0x70, 0xef, 0xf8, 0x69, 0x9f, 0xf7, 0xdb, 0x69, 0x1f, 0xed, 0xec, 0x1d, 0x34, 0x72, 0x0c, 0xa1, 0xed, 0x75, 0x0f, 0xda, 0x3b, 0x6c, 0x86, 0xac, 0xf1, 0xf4, 0xe8, 0xa8, 0x73, 0xb4, 0xdf, 0xc8, 0xbf, 0xf5, 0xf7, 0x0a, 0x94, 0x31, 0x86, 0x3c, 0xb1, 0x1d, 0x8b, 0xf5, 0x39, 0x0e, 0xcf, 0xa9, 0x1f, 0x34, 0x16, 0x98, 0x22, 0xf7, 0x77, 0x1a, 0x0a, 0x59, 0xc2, 0x30, 0xd2, 0xc8, 0xa1, 0x8c, 0xa6, 0xe1, 0x34, 0x16, 0x99, 0x8c, 0xb1, 0x00, 0xd1, 0xc8, 0xb3, 0x7e, 0xdc, 0xef, 0x1b, 0x05, 0x86, 0x8c, 0xc5, 0x80, 0x46, 0x91, 0x31, 0xe8, 0x8e, 0xc2, 0xc6, 0x12, 0xa9, 0x4e, 0x9c, 0xbf, 0x51, 0x22, 0xad, 0x79, 0xee, 0xde, 0x28, 0xa3, 0xec, 0xe8, 0xc4, 0x0d, 0x60, 0xbd, 0xa4, 0xdb, 0x36, 0x2a, 0x0f, 0xff, 0x7b, 0x0d, 0x72, 0xdd, 0x5d, 0xd2, 0x06, 0x98, 0xbc, 0x76, 0x22, 0x9b, 0xb3, 0xef, 0x9f, 0xd0, 0x70, 0x5b, 0xcd, 0x79, 0x0f, 0xa3, 0xd4, 0x05, 0xf2, 0x2e, 0x2c, 0xf6, 0x03, 0x97, 0x88, 0xf4, 0x7c, 0xf2, 0x81, 0x4f, 0x6b, 0x25, 0x06, 0x91, 0xd4, 0x6f, 0x28, 0xef, 0x2a, 0xe4, 0x13, 0x28, 0x47, 0x5f, 0x4f, 0x10, 0xf1, 0xf5, 0x55, 0xf2, 0xf3, 0x95, 0xd6, 0xe6, 0x0c, 0x3c, 0x1a, 0xf1, 0x10, 0xea, 0xd3, 0xdf, 0x5f, 0x90, 0x9b, 0x9c, 0x38, 0xf5, 0xdb, 0x8e, 0xd6, 0xb7, 0xd2, 0x91, 0x11, 0xbb, 0x8f, 0x60, 0x49, 0x7c, 0x23, 0x41, 0x84, 0x83, 0x4c, 0x7f, 0x71, 0xd1, 0x5a, 0x4f, 0x40, 0xa3, 0x9e, 0xbf, 0x08, 0x25, 0xf9, 0xc1, 0x02, 0x59, 0x8f, 0x54, 0x14, 0xff, 0x62, 0xa0, 0xb5, 0x91, 0x04, 0xc7, 0x3b, 0xcb, 0x87, 0xff, 0xb2, 0x73, 0xe2, 0x73, 0x03, 0xd9, 0x39, 0xf9, 0x7d, 0x80, 0xba, 0x40, 0xf6, 0xa1, 0x1a, 0x7f, 0x1f, 0x4f, 0x6e, 0x44, 0xc3, 0x24, 0x5f, 0xec, 0xb7, 0x5a, 0x69, 0xa8, 0xb8, 0x2e, 0xa7, 0x6b, 0x92, 0x52, 0x97, 0xa9, 0x55, 0x62, 0xa9, 0xcb, 0xf4, 0x32, 0xa6, 0xba, 0x40, 0xfa, 0xb0, 0x9c, 0x78, 0x0a, 0x42, 0xbe, 0x15, 0x3f, 0xb7, 0xcd, 0x30, 0xbc, 0x35, 0x07, 0x9b, 0x34, 0x98, 0xe8, 0xd5, 0x37, 0x99, 0x68, 0x74, 0xea, 0xe4, 0xdc, 0xda, 0x9c, 0x81, 0x47, 0x52, 0x6d, 0x43, 0x6d, 0x9f, 0x86, 0x5d, 0x9f, 0x5e, 0x66, 0xe7, 0xf1, 0x08, 0x79, 0x4c, 0x5e, 0x9e, 0x93, 0x56, 0x82, 0x36, 0xf6, 0x1c, 0xfd, 0x45, 0x7c, 0x76, 0xa1, 0x12, 0x7b, 0xef, 0x4c, 0x84, 0x67, 0xcd, 0x3e, 0x27, 0x6f, 0xdd, 0x48, 0xc1, 0x44, 0x5c, 0x3e, 0x81, 0x92, 0x7c, 0x37, 0x21, 0x8d, 0x27, 0xf1, 0x60, 0x43, 0x1a, 0x4f, 0xf2, 0x79, 0x85, 0xba, 0xf8, 0xc3, 0x9c, 0x42, 0xf6, 0xa1, 0x12, 0x7b, 0x61, 0x20, 0xa5, 0x98, 0x7d, 0x01, 0x21, 0xa5, 0x48, 0x79, 0x8e, 0xc0, 0x19, 0x7d, 0x0a, 0xb5, 0xa9, 0x5b, 0x78, 0xa9, 0x96, 0xb4, 0x97, 0x07, 0xad, 0x9b, 0xa9, 0xb8, 0x68, 0x52, 0x3d, 0x68, 0x24, 0xef, 0xbd, 0xc9, 0xad, 0xf8, 0xf8, 0xb3, 0x1c, 0x6f, 0xcf, 0x43, 0xc7, 0x99, 0x26, 0xdf, 0x53, 0x4b, 0xa6, 0x73, 0xde, 0x6b, 0x4b, 0xa6, 0xf3, 0x9e, 0x61, 0x73, 0xa6, 0xc9, 0xc7, 0xcb, 0x92, 0xe9, 0x9c, 0x77, 0xd4, 0x92, 0xe9, 0xbc, 0x37, 0xcf, 0xea, 0x02, 0x53, 0xe5, 0xd4, 0xf9, 0x42, 0xaa, 0x32, 0xad, 0x16, 0x2e, 0x55, 0x99, 0x5a, 0x1d, 0xe6, 0x6e, 0x3d, 0x5d, 0x7a, 0x95, 0x6e, 0x9d, 0x5a, 0xd6, 0x95, 0x6e, 0x9d, 0x5e, 0xad, 0x55, 0x17, 0xc8, 0x67, 0xb0, 0x32, 0x53, 0xfa, 0x24, 0x62, 0x46, 0xf3, 0x6a, 0xaf, 0xad, 0x3b, 0x73, 0xf1, 0x11, 0xdf, 0x0b, 0x59, 0xba, 0x9d, 0xad, 0x1f, 0x92, 0xd7, 0xe3, 0xdd, 0xe7, 0x16, 0x40, 0x5b, 0x0f, 0xae, 0x22, 0x8b, 0x79, 0x70, 0x65, 0x52, 0xe5, 0x8a, 0x36, 0xbb, 0x99, 0x12, 0x9c, 0xdc, 0xec, 0x66, 0x2b, 0x62, 0x22, 0x1a, 0xed, 0x42, 0x25, 0x56, 0xa8, 0x21, 0x93, 0xbd, 0x31, 0x51, 0x1c, 0x6a, 0xdd, 0x48, 0xc1, 0xc4, 0x3c, 0xb8, 0x1c, 0x15, 0x2b, 0x64, 0x3c, 0x4a, 0x96, 0x51, 0x5a, 0x9b, 0x33, 0xf0, 0xf8, 0x0e, 0x10, 0x3f, 0xd1, 0xcb, 0x1d, 0x20, 0xa5, 0xd4, 0x20, 0x77, 0x80, 0xb4, 0x02, 0x80, 0xba, 0x40, 0x28, 0x6c, 0xa4, 0x1f, 0x6f, 0xc9, 0xbd, 0x58, 0xbf, 0x79, 0x27, 0xf4, 0xd6, 0xfd, 0x17, 0x13, 0xc5, 0x4d, 0x68, 0xe6, 0xbc, 0x47, 0x26, 0x9e, 0x96, 0x7a, 0xe6, 0x94, 0x26, 0x34, 0xf7, 0xa0, 0xc8, 0xf9, 0xce, 0x7c, 0x59, 0x2e, 0xf9, 0xce, 0xfb, 0x80, 0x5d, 0xf2, 0x9d, 0xfb, 0x49, 0x3a, 0x77, 0xf1, 0xe4, 0x07, 0xe4, 0xd2, 0xc5, 0xe7, 0x7c, 0x89, 0x2e, 0x5d, 0x7c, 0xde, 0x77, 0xe7, 0xea, 0x02, 0xf9, 0x1e, 0xac, 0xcc, 0x7c, 0xa3, 0x2f, 0x85, 0x9d, 0xf7, 0x61, 0xbf, 0x14, 0x76, 0xee, 0xc7, 0xfd, 0xea, 0xc2, 0xbb, 0x0a, 0x39, 0x80, 0xda, 0xd4, 0xf9, 0x46, 0x06, 0x8f, 0xb4, 0xc3, 0x99, 0x0c, 0x1e, 0xa9, 0x07, 0x22, 0x66, 0xe4, 0xe4, 0xfb, 0xf2, 0x01, 0x5a, 0xfc, 0x5c, 0xd1, 0x23, 0x77, 0xe3, 0xfd, 0xd2, 0x0e, 0x40, 0xad, 0xd7, 0x5e, 0x40, 0x21, 0xf9, 0x6f, 0x3f, 0xf8, 0xb7, 0xbf, 0x2b, 0x29, 0xff, 0xfa, 0xd5, 0x6d, 0xe5, 0x67, 0x5f, 0xdd, 0x56, 0xfe, 0xe3, 0xab, 0xdb, 0xca, 0x9f, 0xff, 0xe7, 0xed, 0x05, 0x68, 0xb8, 0xfe, 0xd9, 0x56, 0x68, 0x5f, 0x5c, 0x6e, 0x5d, 0x5c, 0xe2, 0x7f, 0x3b, 0x38, 0x29, 0xe2, 0x9f, 0xf7, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x5d, 0xcf, 0x9c, 0x01, 0x7b, 0x41, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/raft_cmdpb/000077500000000000000000000000001421456440000171675ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/raft_cmdpb/raft_cmdpb.pb.go000066400000000000000000011420671421456440000222320ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: raft_cmdpb.proto package raft_cmdpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" eraftpb "github.com/pingcap/kvproto/pkg/eraftpb" errorpb "github.com/pingcap/kvproto/pkg/errorpb" import_sstpb "github.com/pingcap/kvproto/pkg/import_sstpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" metapb "github.com/pingcap/kvproto/pkg/metapb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type CmdType int32 const ( CmdType_Invalid CmdType = 0 CmdType_Get CmdType = 1 CmdType_Put CmdType = 3 CmdType_Delete CmdType = 4 CmdType_Snap CmdType = 5 CmdType_Prewrite CmdType = 6 CmdType_DeleteRange CmdType = 7 CmdType_IngestSST CmdType = 8 CmdType_ReadIndex CmdType = 9 ) var CmdType_name = map[int32]string{ 0: "Invalid", 1: "Get", 3: "Put", 4: "Delete", 5: "Snap", 6: "Prewrite", 7: "DeleteRange", 8: "IngestSST", 9: "ReadIndex", } var CmdType_value = map[string]int32{ "Invalid": 0, "Get": 1, "Put": 3, "Delete": 4, "Snap": 5, "Prewrite": 6, "DeleteRange": 7, "IngestSST": 8, "ReadIndex": 9, } func (x CmdType) String() string { return proto.EnumName(CmdType_name, int32(x)) } func (CmdType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{0} } type AdminCmdType int32 const ( AdminCmdType_InvalidAdmin AdminCmdType = 0 AdminCmdType_ChangePeer AdminCmdType = 1 // Use `BatchSplit` instead. AdminCmdType_Split AdminCmdType = 2 // Deprecated: Do not use. AdminCmdType_CompactLog AdminCmdType = 3 AdminCmdType_TransferLeader AdminCmdType = 4 AdminCmdType_ComputeHash AdminCmdType = 5 AdminCmdType_VerifyHash AdminCmdType = 6 AdminCmdType_PrepareMerge AdminCmdType = 7 AdminCmdType_CommitMerge AdminCmdType = 8 AdminCmdType_RollbackMerge AdminCmdType = 9 AdminCmdType_BatchSplit AdminCmdType = 10 AdminCmdType_ChangePeerV2 AdminCmdType = 11 ) var AdminCmdType_name = map[int32]string{ 0: "InvalidAdmin", 1: "ChangePeer", 2: "Split", 3: "CompactLog", 4: "TransferLeader", 5: "ComputeHash", 6: "VerifyHash", 7: "PrepareMerge", 8: "CommitMerge", 9: "RollbackMerge", 10: "BatchSplit", 11: "ChangePeerV2", } var AdminCmdType_value = map[string]int32{ "InvalidAdmin": 0, "ChangePeer": 1, "Split": 2, "CompactLog": 3, "TransferLeader": 4, "ComputeHash": 5, "VerifyHash": 6, "PrepareMerge": 7, "CommitMerge": 8, "RollbackMerge": 9, "BatchSplit": 10, "ChangePeerV2": 11, } func (x AdminCmdType) String() string { return proto.EnumName(AdminCmdType_name, int32(x)) } func (AdminCmdType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{1} } type StatusCmdType int32 const ( StatusCmdType_InvalidStatus StatusCmdType = 0 StatusCmdType_RegionLeader StatusCmdType = 1 StatusCmdType_RegionDetail StatusCmdType = 2 ) var StatusCmdType_name = map[int32]string{ 0: "InvalidStatus", 1: "RegionLeader", 2: "RegionDetail", } var StatusCmdType_value = map[string]int32{ "InvalidStatus": 0, "RegionLeader": 1, "RegionDetail": 2, } func (x StatusCmdType) String() string { return proto.EnumName(StatusCmdType_name, int32(x)) } func (StatusCmdType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{2} } type GetRequest struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetRequest) Reset() { *m = GetRequest{} } func (m *GetRequest) String() string { return proto.CompactTextString(m) } func (*GetRequest) ProtoMessage() {} func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{0} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetRequest.Merge(dst, 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 func (m *GetRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *GetRequest) GetKey() []byte { if m != nil { return m.Key } return nil } type GetResponse struct { Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } func (m *GetResponse) String() string { return proto.CompactTextString(m) } func (*GetResponse) ProtoMessage() {} func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{1} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GetResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_GetResponse.Merge(dst, 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 func (m *GetResponse) GetValue() []byte { if m != nil { return m.Value } return nil } type PutRequest struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutRequest) Reset() { *m = PutRequest{} } func (m *PutRequest) String() string { return proto.CompactTextString(m) } func (*PutRequest) ProtoMessage() {} func (*PutRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{2} } func (m *PutRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PutRequest.Merge(dst, src) } func (m *PutRequest) XXX_Size() int { return m.Size() } func (m *PutRequest) XXX_DiscardUnknown() { xxx_messageInfo_PutRequest.DiscardUnknown(m) } var xxx_messageInfo_PutRequest proto.InternalMessageInfo func (m *PutRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *PutRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *PutRequest) GetValue() []byte { if m != nil { return m.Value } return nil } type PutResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PutResponse) Reset() { *m = PutResponse{} } func (m *PutResponse) String() string { return proto.CompactTextString(m) } func (*PutResponse) ProtoMessage() {} func (*PutResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{3} } func (m *PutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PutResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PutResponse.Merge(dst, src) } func (m *PutResponse) XXX_Size() int { return m.Size() } func (m *PutResponse) XXX_DiscardUnknown() { xxx_messageInfo_PutResponse.DiscardUnknown(m) } var xxx_messageInfo_PutResponse proto.InternalMessageInfo type DeleteRequest struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRequest) ProtoMessage() {} func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{4} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRequest.Merge(dst, 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 func (m *DeleteRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *DeleteRequest) GetKey() []byte { if m != nil { return m.Key } return nil } type DeleteResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } func (*DeleteResponse) ProtoMessage() {} func (*DeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteResponse.Merge(dst, 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 DeleteRangeRequest struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` NotifyOnly bool `protobuf:"varint,4,opt,name=notify_only,json=notifyOnly,proto3" json:"notify_only,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } func (*DeleteRangeRequest) ProtoMessage() {} func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{6} } func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteRangeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRangeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRangeRequest.Merge(dst, src) } func (m *DeleteRangeRequest) XXX_Size() int { return m.Size() } func (m *DeleteRangeRequest) XXX_DiscardUnknown() { xxx_messageInfo_DeleteRangeRequest.DiscardUnknown(m) } var xxx_messageInfo_DeleteRangeRequest proto.InternalMessageInfo func (m *DeleteRangeRequest) GetCf() string { if m != nil { return m.Cf } return "" } func (m *DeleteRangeRequest) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *DeleteRangeRequest) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *DeleteRangeRequest) GetNotifyOnly() bool { if m != nil { return m.NotifyOnly } return false } type DeleteRangeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } func (*DeleteRangeResponse) ProtoMessage() {} func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{7} } func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DeleteRangeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DeleteRangeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_DeleteRangeResponse.Merge(dst, src) } func (m *DeleteRangeResponse) XXX_Size() int { return m.Size() } func (m *DeleteRangeResponse) XXX_DiscardUnknown() { xxx_messageInfo_DeleteRangeResponse.DiscardUnknown(m) } var xxx_messageInfo_DeleteRangeResponse proto.InternalMessageInfo type SnapRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapRequest) Reset() { *m = SnapRequest{} } func (m *SnapRequest) String() string { return proto.CompactTextString(m) } func (*SnapRequest) ProtoMessage() {} func (*SnapRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{8} } func (m *SnapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapRequest.Merge(dst, src) } func (m *SnapRequest) XXX_Size() int { return m.Size() } func (m *SnapRequest) XXX_DiscardUnknown() { xxx_messageInfo_SnapRequest.DiscardUnknown(m) } var xxx_messageInfo_SnapRequest proto.InternalMessageInfo type SnapResponse struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapResponse) Reset() { *m = SnapResponse{} } func (m *SnapResponse) String() string { return proto.CompactTextString(m) } func (*SnapResponse) ProtoMessage() {} func (*SnapResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{9} } func (m *SnapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapResponse.Merge(dst, src) } func (m *SnapResponse) XXX_Size() int { return m.Size() } func (m *SnapResponse) XXX_DiscardUnknown() { xxx_messageInfo_SnapResponse.DiscardUnknown(m) } var xxx_messageInfo_SnapResponse proto.InternalMessageInfo func (m *SnapResponse) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } type PrewriteRequest struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` Lock []byte `protobuf:"bytes,3,opt,name=lock,proto3" json:"lock,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrewriteRequest) Reset() { *m = PrewriteRequest{} } func (m *PrewriteRequest) String() string { return proto.CompactTextString(m) } func (*PrewriteRequest) ProtoMessage() {} func (*PrewriteRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{10} } func (m *PrewriteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrewriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrewriteRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrewriteRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PrewriteRequest.Merge(dst, src) } func (m *PrewriteRequest) XXX_Size() int { return m.Size() } func (m *PrewriteRequest) XXX_DiscardUnknown() { xxx_messageInfo_PrewriteRequest.DiscardUnknown(m) } var xxx_messageInfo_PrewriteRequest proto.InternalMessageInfo func (m *PrewriteRequest) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *PrewriteRequest) GetValue() []byte { if m != nil { return m.Value } return nil } func (m *PrewriteRequest) GetLock() []byte { if m != nil { return m.Lock } return nil } type PrewriteResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrewriteResponse) Reset() { *m = PrewriteResponse{} } func (m *PrewriteResponse) String() string { return proto.CompactTextString(m) } func (*PrewriteResponse) ProtoMessage() {} func (*PrewriteResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{11} } func (m *PrewriteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrewriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrewriteResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrewriteResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PrewriteResponse.Merge(dst, src) } func (m *PrewriteResponse) XXX_Size() int { return m.Size() } func (m *PrewriteResponse) XXX_DiscardUnknown() { xxx_messageInfo_PrewriteResponse.DiscardUnknown(m) } var xxx_messageInfo_PrewriteResponse proto.InternalMessageInfo type IngestSSTRequest struct { Sst *import_sstpb.SSTMeta `protobuf:"bytes,1,opt,name=sst" json:"sst,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IngestSSTRequest) Reset() { *m = IngestSSTRequest{} } func (m *IngestSSTRequest) String() string { return proto.CompactTextString(m) } func (*IngestSSTRequest) ProtoMessage() {} func (*IngestSSTRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{12} } func (m *IngestSSTRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IngestSSTRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IngestSSTRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IngestSSTRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_IngestSSTRequest.Merge(dst, src) } func (m *IngestSSTRequest) XXX_Size() int { return m.Size() } func (m *IngestSSTRequest) XXX_DiscardUnknown() { xxx_messageInfo_IngestSSTRequest.DiscardUnknown(m) } var xxx_messageInfo_IngestSSTRequest proto.InternalMessageInfo func (m *IngestSSTRequest) GetSst() *import_sstpb.SSTMeta { if m != nil { return m.Sst } return nil } type IngestSSTResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IngestSSTResponse) Reset() { *m = IngestSSTResponse{} } func (m *IngestSSTResponse) String() string { return proto.CompactTextString(m) } func (*IngestSSTResponse) ProtoMessage() {} func (*IngestSSTResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{13} } func (m *IngestSSTResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IngestSSTResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IngestSSTResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *IngestSSTResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_IngestSSTResponse.Merge(dst, src) } func (m *IngestSSTResponse) XXX_Size() int { return m.Size() } func (m *IngestSSTResponse) XXX_DiscardUnknown() { xxx_messageInfo_IngestSSTResponse.DiscardUnknown(m) } var xxx_messageInfo_IngestSSTResponse proto.InternalMessageInfo type ReadIndexRequest struct { // In replica read, leader uses start_ts and key_ranges to check memory locks. StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` KeyRanges []*kvrpcpb.KeyRange `protobuf:"bytes,2,rep,name=key_ranges,json=keyRanges" json:"key_ranges,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadIndexRequest) Reset() { *m = ReadIndexRequest{} } func (m *ReadIndexRequest) String() string { return proto.CompactTextString(m) } func (*ReadIndexRequest) ProtoMessage() {} func (*ReadIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{14} } func (m *ReadIndexRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadIndexRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadIndexRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadIndexRequest.Merge(dst, src) } func (m *ReadIndexRequest) XXX_Size() int { return m.Size() } func (m *ReadIndexRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReadIndexRequest.DiscardUnknown(m) } var xxx_messageInfo_ReadIndexRequest proto.InternalMessageInfo func (m *ReadIndexRequest) GetStartTs() uint64 { if m != nil { return m.StartTs } return 0 } func (m *ReadIndexRequest) GetKeyRanges() []*kvrpcpb.KeyRange { if m != nil { return m.KeyRanges } return nil } type ReadIndexResponse struct { ReadIndex uint64 `protobuf:"varint,1,opt,name=read_index,json=readIndex,proto3" json:"read_index,omitempty"` // The memory lock blocking this read at the leader Locked *kvrpcpb.LockInfo `protobuf:"bytes,2,opt,name=locked" json:"locked,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReadIndexResponse) Reset() { *m = ReadIndexResponse{} } func (m *ReadIndexResponse) String() string { return proto.CompactTextString(m) } func (*ReadIndexResponse) ProtoMessage() {} func (*ReadIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{15} } func (m *ReadIndexResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReadIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReadIndexResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReadIndexResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReadIndexResponse.Merge(dst, src) } func (m *ReadIndexResponse) XXX_Size() int { return m.Size() } func (m *ReadIndexResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReadIndexResponse.DiscardUnknown(m) } var xxx_messageInfo_ReadIndexResponse proto.InternalMessageInfo func (m *ReadIndexResponse) GetReadIndex() uint64 { if m != nil { return m.ReadIndex } return 0 } func (m *ReadIndexResponse) GetLocked() *kvrpcpb.LockInfo { if m != nil { return m.Locked } return nil } type Request struct { CmdType CmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.CmdType" json:"cmd_type,omitempty"` Get *GetRequest `protobuf:"bytes,2,opt,name=get" json:"get,omitempty"` Put *PutRequest `protobuf:"bytes,4,opt,name=put" json:"put,omitempty"` Delete *DeleteRequest `protobuf:"bytes,5,opt,name=delete" json:"delete,omitempty"` Snap *SnapRequest `protobuf:"bytes,6,opt,name=snap" json:"snap,omitempty"` Prewrite *PrewriteRequest `protobuf:"bytes,7,opt,name=prewrite" json:"prewrite,omitempty"` DeleteRange *DeleteRangeRequest `protobuf:"bytes,8,opt,name=delete_range,json=deleteRange" json:"delete_range,omitempty"` IngestSst *IngestSSTRequest `protobuf:"bytes,9,opt,name=ingest_sst,json=ingestSst" json:"ingest_sst,omitempty"` ReadIndex *ReadIndexRequest `protobuf:"bytes,10,opt,name=read_index,json=readIndex" json:"read_index,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Request) Reset() { *m = Request{} } func (m *Request) String() string { return proto.CompactTextString(m) } func (*Request) ProtoMessage() {} func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{16} } func (m *Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Request) XXX_Merge(src proto.Message) { xxx_messageInfo_Request.Merge(dst, src) } func (m *Request) XXX_Size() int { return m.Size() } func (m *Request) XXX_DiscardUnknown() { xxx_messageInfo_Request.DiscardUnknown(m) } var xxx_messageInfo_Request proto.InternalMessageInfo func (m *Request) GetCmdType() CmdType { if m != nil { return m.CmdType } return CmdType_Invalid } func (m *Request) GetGet() *GetRequest { if m != nil { return m.Get } return nil } func (m *Request) GetPut() *PutRequest { if m != nil { return m.Put } return nil } func (m *Request) GetDelete() *DeleteRequest { if m != nil { return m.Delete } return nil } func (m *Request) GetSnap() *SnapRequest { if m != nil { return m.Snap } return nil } func (m *Request) GetPrewrite() *PrewriteRequest { if m != nil { return m.Prewrite } return nil } func (m *Request) GetDeleteRange() *DeleteRangeRequest { if m != nil { return m.DeleteRange } return nil } func (m *Request) GetIngestSst() *IngestSSTRequest { if m != nil { return m.IngestSst } return nil } func (m *Request) GetReadIndex() *ReadIndexRequest { if m != nil { return m.ReadIndex } return nil } type Response struct { CmdType CmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.CmdType" json:"cmd_type,omitempty"` Get *GetResponse `protobuf:"bytes,2,opt,name=get" json:"get,omitempty"` Put *PutResponse `protobuf:"bytes,4,opt,name=put" json:"put,omitempty"` Delete *DeleteResponse `protobuf:"bytes,5,opt,name=delete" json:"delete,omitempty"` Snap *SnapResponse `protobuf:"bytes,6,opt,name=snap" json:"snap,omitempty"` Prewrite *PrewriteResponse `protobuf:"bytes,7,opt,name=prewrite" json:"prewrite,omitempty"` DelteRange *DeleteRangeResponse `protobuf:"bytes,8,opt,name=delte_range,json=delteRange" json:"delte_range,omitempty"` IngestSst *IngestSSTResponse `protobuf:"bytes,9,opt,name=ingest_sst,json=ingestSst" json:"ingest_sst,omitempty"` ReadIndex *ReadIndexResponse `protobuf:"bytes,10,opt,name=read_index,json=readIndex" json:"read_index,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{17} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Response) XXX_Merge(src proto.Message) { xxx_messageInfo_Response.Merge(dst, src) } func (m *Response) XXX_Size() int { return m.Size() } func (m *Response) XXX_DiscardUnknown() { xxx_messageInfo_Response.DiscardUnknown(m) } var xxx_messageInfo_Response proto.InternalMessageInfo func (m *Response) GetCmdType() CmdType { if m != nil { return m.CmdType } return CmdType_Invalid } func (m *Response) GetGet() *GetResponse { if m != nil { return m.Get } return nil } func (m *Response) GetPut() *PutResponse { if m != nil { return m.Put } return nil } func (m *Response) GetDelete() *DeleteResponse { if m != nil { return m.Delete } return nil } func (m *Response) GetSnap() *SnapResponse { if m != nil { return m.Snap } return nil } func (m *Response) GetPrewrite() *PrewriteResponse { if m != nil { return m.Prewrite } return nil } func (m *Response) GetDelteRange() *DeleteRangeResponse { if m != nil { return m.DelteRange } return nil } func (m *Response) GetIngestSst() *IngestSSTResponse { if m != nil { return m.IngestSst } return nil } func (m *Response) GetReadIndex() *ReadIndexResponse { if m != nil { return m.ReadIndex } return nil } type ChangePeerRequest struct { // This can be only called in internal RaftStore now. ChangeType eraftpb.ConfChangeType `protobuf:"varint,1,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` Peer *metapb.Peer `protobuf:"bytes,2,opt,name=peer" json:"peer,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeerRequest) Reset() { *m = ChangePeerRequest{} } func (m *ChangePeerRequest) String() string { return proto.CompactTextString(m) } func (*ChangePeerRequest) ProtoMessage() {} func (*ChangePeerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{18} } func (m *ChangePeerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeerRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeerRequest.Merge(dst, src) } func (m *ChangePeerRequest) XXX_Size() int { return m.Size() } func (m *ChangePeerRequest) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeerRequest.DiscardUnknown(m) } var xxx_messageInfo_ChangePeerRequest proto.InternalMessageInfo func (m *ChangePeerRequest) GetChangeType() eraftpb.ConfChangeType { if m != nil { return m.ChangeType } return eraftpb.ConfChangeType_AddNode } func (m *ChangePeerRequest) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } type ChangePeerResponse struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeerResponse) Reset() { *m = ChangePeerResponse{} } func (m *ChangePeerResponse) String() string { return proto.CompactTextString(m) } func (*ChangePeerResponse) ProtoMessage() {} func (*ChangePeerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{19} } func (m *ChangePeerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeerResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeerResponse.Merge(dst, src) } func (m *ChangePeerResponse) XXX_Size() int { return m.Size() } func (m *ChangePeerResponse) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeerResponse.DiscardUnknown(m) } var xxx_messageInfo_ChangePeerResponse proto.InternalMessageInfo func (m *ChangePeerResponse) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } type ChangePeerV2Request struct { Changes []*ChangePeerRequest `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeerV2Request) Reset() { *m = ChangePeerV2Request{} } func (m *ChangePeerV2Request) String() string { return proto.CompactTextString(m) } func (*ChangePeerV2Request) ProtoMessage() {} func (*ChangePeerV2Request) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{20} } func (m *ChangePeerV2Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeerV2Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeerV2Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeerV2Request) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeerV2Request.Merge(dst, src) } func (m *ChangePeerV2Request) XXX_Size() int { return m.Size() } func (m *ChangePeerV2Request) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeerV2Request.DiscardUnknown(m) } var xxx_messageInfo_ChangePeerV2Request proto.InternalMessageInfo func (m *ChangePeerV2Request) GetChanges() []*ChangePeerRequest { if m != nil { return m.Changes } return nil } type ChangePeerV2Response struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ChangePeerV2Response) Reset() { *m = ChangePeerV2Response{} } func (m *ChangePeerV2Response) String() string { return proto.CompactTextString(m) } func (*ChangePeerV2Response) ProtoMessage() {} func (*ChangePeerV2Response) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{21} } func (m *ChangePeerV2Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ChangePeerV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ChangePeerV2Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ChangePeerV2Response) XXX_Merge(src proto.Message) { xxx_messageInfo_ChangePeerV2Response.Merge(dst, src) } func (m *ChangePeerV2Response) XXX_Size() int { return m.Size() } func (m *ChangePeerV2Response) XXX_DiscardUnknown() { xxx_messageInfo_ChangePeerV2Response.DiscardUnknown(m) } var xxx_messageInfo_ChangePeerV2Response proto.InternalMessageInfo func (m *ChangePeerV2Response) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } type SplitRequest struct { // This can be only called in internal RaftStore now. // The split_key must be in the been splitting region. SplitKey []byte `protobuf:"bytes,1,opt,name=split_key,json=splitKey,proto3" json:"split_key,omitempty"` // We split the region into two, first uses the origin // parent region id, and the second uses the new_region_id. // We must guarantee that the new_region_id is global unique. NewRegionId uint64 `protobuf:"varint,2,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` // The peer ids for the new split region. NewPeerIds []uint64 `protobuf:"varint,3,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` // If true, right region derive the origin region_id, // left region use new_region_id. // Will be ignored in batch split, use `BatchSplitRequest::right_derive` instead. RightDerive bool `protobuf:"varint,4,opt,name=right_derive,json=rightDerive,proto3" json:"right_derive,omitempty"` // Deprecated: Do not use. XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitRequest) Reset() { *m = SplitRequest{} } func (m *SplitRequest) String() string { return proto.CompactTextString(m) } func (*SplitRequest) ProtoMessage() {} func (*SplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{22} } func (m *SplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitRequest.Merge(dst, src) } func (m *SplitRequest) XXX_Size() int { return m.Size() } func (m *SplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_SplitRequest.DiscardUnknown(m) } var xxx_messageInfo_SplitRequest proto.InternalMessageInfo func (m *SplitRequest) GetSplitKey() []byte { if m != nil { return m.SplitKey } return nil } func (m *SplitRequest) GetNewRegionId() uint64 { if m != nil { return m.NewRegionId } return 0 } func (m *SplitRequest) GetNewPeerIds() []uint64 { if m != nil { return m.NewPeerIds } return nil } // Deprecated: Do not use. func (m *SplitRequest) GetRightDerive() bool { if m != nil { return m.RightDerive } return false } type SplitResponse struct { Left *metapb.Region `protobuf:"bytes,1,opt,name=left" json:"left,omitempty"` Right *metapb.Region `protobuf:"bytes,2,opt,name=right" json:"right,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SplitResponse) Reset() { *m = SplitResponse{} } func (m *SplitResponse) String() string { return proto.CompactTextString(m) } func (*SplitResponse) ProtoMessage() {} func (*SplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{23} } func (m *SplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_SplitResponse.Merge(dst, src) } func (m *SplitResponse) XXX_Size() int { return m.Size() } func (m *SplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_SplitResponse.DiscardUnknown(m) } var xxx_messageInfo_SplitResponse proto.InternalMessageInfo func (m *SplitResponse) GetLeft() *metapb.Region { if m != nil { return m.Left } return nil } func (m *SplitResponse) GetRight() *metapb.Region { if m != nil { return m.Right } return nil } type BatchSplitRequest struct { Requests []*SplitRequest `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"` // If true, the last region derive the origin region_id, // other regions use new ids. RightDerive bool `protobuf:"varint,2,opt,name=right_derive,json=rightDerive,proto3" json:"right_derive,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchSplitRequest) Reset() { *m = BatchSplitRequest{} } func (m *BatchSplitRequest) String() string { return proto.CompactTextString(m) } func (*BatchSplitRequest) ProtoMessage() {} func (*BatchSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{24} } func (m *BatchSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchSplitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchSplitRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchSplitRequest.Merge(dst, src) } func (m *BatchSplitRequest) XXX_Size() int { return m.Size() } func (m *BatchSplitRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchSplitRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchSplitRequest proto.InternalMessageInfo func (m *BatchSplitRequest) GetRequests() []*SplitRequest { if m != nil { return m.Requests } return nil } func (m *BatchSplitRequest) GetRightDerive() bool { if m != nil { return m.RightDerive } return false } type BatchSplitResponse struct { Regions []*metapb.Region `protobuf:"bytes,1,rep,name=regions" json:"regions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchSplitResponse) Reset() { *m = BatchSplitResponse{} } func (m *BatchSplitResponse) String() string { return proto.CompactTextString(m) } func (*BatchSplitResponse) ProtoMessage() {} func (*BatchSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{25} } func (m *BatchSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchSplitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchSplitResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchSplitResponse.Merge(dst, src) } func (m *BatchSplitResponse) XXX_Size() int { return m.Size() } func (m *BatchSplitResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchSplitResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchSplitResponse proto.InternalMessageInfo func (m *BatchSplitResponse) GetRegions() []*metapb.Region { if m != nil { return m.Regions } return nil } type CompactLogRequest struct { CompactIndex uint64 `protobuf:"varint,1,opt,name=compact_index,json=compactIndex,proto3" json:"compact_index,omitempty"` CompactTerm uint64 `protobuf:"varint,2,opt,name=compact_term,json=compactTerm,proto3" json:"compact_term,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactLogRequest) Reset() { *m = CompactLogRequest{} } func (m *CompactLogRequest) String() string { return proto.CompactTextString(m) } func (*CompactLogRequest) ProtoMessage() {} func (*CompactLogRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{26} } func (m *CompactLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactLogRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactLogRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactLogRequest.Merge(dst, src) } func (m *CompactLogRequest) XXX_Size() int { return m.Size() } func (m *CompactLogRequest) XXX_DiscardUnknown() { xxx_messageInfo_CompactLogRequest.DiscardUnknown(m) } var xxx_messageInfo_CompactLogRequest proto.InternalMessageInfo func (m *CompactLogRequest) GetCompactIndex() uint64 { if m != nil { return m.CompactIndex } return 0 } func (m *CompactLogRequest) GetCompactTerm() uint64 { if m != nil { return m.CompactTerm } return 0 } type CompactLogResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CompactLogResponse) Reset() { *m = CompactLogResponse{} } func (m *CompactLogResponse) String() string { return proto.CompactTextString(m) } func (*CompactLogResponse) ProtoMessage() {} func (*CompactLogResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{27} } func (m *CompactLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CompactLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CompactLogResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CompactLogResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CompactLogResponse.Merge(dst, src) } func (m *CompactLogResponse) XXX_Size() int { return m.Size() } func (m *CompactLogResponse) XXX_DiscardUnknown() { xxx_messageInfo_CompactLogResponse.DiscardUnknown(m) } var xxx_messageInfo_CompactLogResponse proto.InternalMessageInfo type TransferLeaderRequest struct { Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` Peers []*metapb.Peer `protobuf:"bytes,2,rep,name=peers" json:"peers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TransferLeaderRequest) Reset() { *m = TransferLeaderRequest{} } func (m *TransferLeaderRequest) String() string { return proto.CompactTextString(m) } func (*TransferLeaderRequest) ProtoMessage() {} func (*TransferLeaderRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{28} } func (m *TransferLeaderRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TransferLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TransferLeaderRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TransferLeaderRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_TransferLeaderRequest.Merge(dst, src) } func (m *TransferLeaderRequest) XXX_Size() int { return m.Size() } func (m *TransferLeaderRequest) XXX_DiscardUnknown() { xxx_messageInfo_TransferLeaderRequest.DiscardUnknown(m) } var xxx_messageInfo_TransferLeaderRequest proto.InternalMessageInfo func (m *TransferLeaderRequest) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *TransferLeaderRequest) GetPeers() []*metapb.Peer { if m != nil { return m.Peers } return nil } type TransferLeaderResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TransferLeaderResponse) Reset() { *m = TransferLeaderResponse{} } func (m *TransferLeaderResponse) String() string { return proto.CompactTextString(m) } func (*TransferLeaderResponse) ProtoMessage() {} func (*TransferLeaderResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{29} } func (m *TransferLeaderResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TransferLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TransferLeaderResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TransferLeaderResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_TransferLeaderResponse.Merge(dst, src) } func (m *TransferLeaderResponse) XXX_Size() int { return m.Size() } func (m *TransferLeaderResponse) XXX_DiscardUnknown() { xxx_messageInfo_TransferLeaderResponse.DiscardUnknown(m) } var xxx_messageInfo_TransferLeaderResponse proto.InternalMessageInfo type ComputeHashRequest struct { Context []byte `protobuf:"bytes,1,opt,name=context,proto3" json:"context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ComputeHashRequest) Reset() { *m = ComputeHashRequest{} } func (m *ComputeHashRequest) String() string { return proto.CompactTextString(m) } func (*ComputeHashRequest) ProtoMessage() {} func (*ComputeHashRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{30} } func (m *ComputeHashRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ComputeHashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ComputeHashRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ComputeHashRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ComputeHashRequest.Merge(dst, src) } func (m *ComputeHashRequest) XXX_Size() int { return m.Size() } func (m *ComputeHashRequest) XXX_DiscardUnknown() { xxx_messageInfo_ComputeHashRequest.DiscardUnknown(m) } var xxx_messageInfo_ComputeHashRequest proto.InternalMessageInfo func (m *ComputeHashRequest) GetContext() []byte { if m != nil { return m.Context } return nil } type VerifyHashRequest struct { Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` Context []byte `protobuf:"bytes,3,opt,name=context,proto3" json:"context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *VerifyHashRequest) Reset() { *m = VerifyHashRequest{} } func (m *VerifyHashRequest) String() string { return proto.CompactTextString(m) } func (*VerifyHashRequest) ProtoMessage() {} func (*VerifyHashRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{31} } func (m *VerifyHashRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *VerifyHashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VerifyHashRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *VerifyHashRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_VerifyHashRequest.Merge(dst, src) } func (m *VerifyHashRequest) XXX_Size() int { return m.Size() } func (m *VerifyHashRequest) XXX_DiscardUnknown() { xxx_messageInfo_VerifyHashRequest.DiscardUnknown(m) } var xxx_messageInfo_VerifyHashRequest proto.InternalMessageInfo func (m *VerifyHashRequest) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *VerifyHashRequest) GetHash() []byte { if m != nil { return m.Hash } return nil } func (m *VerifyHashRequest) GetContext() []byte { if m != nil { return m.Context } return nil } type VerifyHashResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *VerifyHashResponse) Reset() { *m = VerifyHashResponse{} } func (m *VerifyHashResponse) String() string { return proto.CompactTextString(m) } func (*VerifyHashResponse) ProtoMessage() {} func (*VerifyHashResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{32} } func (m *VerifyHashResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *VerifyHashResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VerifyHashResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *VerifyHashResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_VerifyHashResponse.Merge(dst, src) } func (m *VerifyHashResponse) XXX_Size() int { return m.Size() } func (m *VerifyHashResponse) XXX_DiscardUnknown() { xxx_messageInfo_VerifyHashResponse.DiscardUnknown(m) } var xxx_messageInfo_VerifyHashResponse proto.InternalMessageInfo type PrepareMergeRequest struct { MinIndex uint64 `protobuf:"varint,1,opt,name=min_index,json=minIndex,proto3" json:"min_index,omitempty"` Target *metapb.Region `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrepareMergeRequest) Reset() { *m = PrepareMergeRequest{} } func (m *PrepareMergeRequest) String() string { return proto.CompactTextString(m) } func (*PrepareMergeRequest) ProtoMessage() {} func (*PrepareMergeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{33} } func (m *PrepareMergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrepareMergeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrepareMergeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrepareMergeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PrepareMergeRequest.Merge(dst, src) } func (m *PrepareMergeRequest) XXX_Size() int { return m.Size() } func (m *PrepareMergeRequest) XXX_DiscardUnknown() { xxx_messageInfo_PrepareMergeRequest.DiscardUnknown(m) } var xxx_messageInfo_PrepareMergeRequest proto.InternalMessageInfo func (m *PrepareMergeRequest) GetMinIndex() uint64 { if m != nil { return m.MinIndex } return 0 } func (m *PrepareMergeRequest) GetTarget() *metapb.Region { if m != nil { return m.Target } return nil } type PrepareMergeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PrepareMergeResponse) Reset() { *m = PrepareMergeResponse{} } func (m *PrepareMergeResponse) String() string { return proto.CompactTextString(m) } func (*PrepareMergeResponse) ProtoMessage() {} func (*PrepareMergeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{34} } func (m *PrepareMergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrepareMergeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrepareMergeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *PrepareMergeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PrepareMergeResponse.Merge(dst, src) } func (m *PrepareMergeResponse) XXX_Size() int { return m.Size() } func (m *PrepareMergeResponse) XXX_DiscardUnknown() { xxx_messageInfo_PrepareMergeResponse.DiscardUnknown(m) } var xxx_messageInfo_PrepareMergeResponse proto.InternalMessageInfo type CommitMergeRequest struct { Source *metapb.Region `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"` Commit uint64 `protobuf:"varint,2,opt,name=commit,proto3" json:"commit,omitempty"` Entries []*eraftpb.Entry `protobuf:"bytes,3,rep,name=entries" json:"entries,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitMergeRequest) Reset() { *m = CommitMergeRequest{} } func (m *CommitMergeRequest) String() string { return proto.CompactTextString(m) } func (*CommitMergeRequest) ProtoMessage() {} func (*CommitMergeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{35} } func (m *CommitMergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitMergeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitMergeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitMergeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitMergeRequest.Merge(dst, src) } func (m *CommitMergeRequest) XXX_Size() int { return m.Size() } func (m *CommitMergeRequest) XXX_DiscardUnknown() { xxx_messageInfo_CommitMergeRequest.DiscardUnknown(m) } var xxx_messageInfo_CommitMergeRequest proto.InternalMessageInfo func (m *CommitMergeRequest) GetSource() *metapb.Region { if m != nil { return m.Source } return nil } func (m *CommitMergeRequest) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } func (m *CommitMergeRequest) GetEntries() []*eraftpb.Entry { if m != nil { return m.Entries } return nil } type CommitMergeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CommitMergeResponse) Reset() { *m = CommitMergeResponse{} } func (m *CommitMergeResponse) String() string { return proto.CompactTextString(m) } func (*CommitMergeResponse) ProtoMessage() {} func (*CommitMergeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{36} } func (m *CommitMergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CommitMergeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CommitMergeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *CommitMergeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CommitMergeResponse.Merge(dst, src) } func (m *CommitMergeResponse) XXX_Size() int { return m.Size() } func (m *CommitMergeResponse) XXX_DiscardUnknown() { xxx_messageInfo_CommitMergeResponse.DiscardUnknown(m) } var xxx_messageInfo_CommitMergeResponse proto.InternalMessageInfo type RollbackMergeRequest struct { Commit uint64 `protobuf:"varint,1,opt,name=commit,proto3" json:"commit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RollbackMergeRequest) Reset() { *m = RollbackMergeRequest{} } func (m *RollbackMergeRequest) String() string { return proto.CompactTextString(m) } func (*RollbackMergeRequest) ProtoMessage() {} func (*RollbackMergeRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{37} } func (m *RollbackMergeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RollbackMergeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RollbackMergeRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RollbackMergeRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RollbackMergeRequest.Merge(dst, src) } func (m *RollbackMergeRequest) XXX_Size() int { return m.Size() } func (m *RollbackMergeRequest) XXX_DiscardUnknown() { xxx_messageInfo_RollbackMergeRequest.DiscardUnknown(m) } var xxx_messageInfo_RollbackMergeRequest proto.InternalMessageInfo func (m *RollbackMergeRequest) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } type RollbackMergeResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RollbackMergeResponse) Reset() { *m = RollbackMergeResponse{} } func (m *RollbackMergeResponse) String() string { return proto.CompactTextString(m) } func (*RollbackMergeResponse) ProtoMessage() {} func (*RollbackMergeResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{38} } func (m *RollbackMergeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RollbackMergeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RollbackMergeResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RollbackMergeResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RollbackMergeResponse.Merge(dst, src) } func (m *RollbackMergeResponse) XXX_Size() int { return m.Size() } func (m *RollbackMergeResponse) XXX_DiscardUnknown() { xxx_messageInfo_RollbackMergeResponse.DiscardUnknown(m) } var xxx_messageInfo_RollbackMergeResponse proto.InternalMessageInfo type AdminRequest struct { CmdType AdminCmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.AdminCmdType" json:"cmd_type,omitempty"` ChangePeer *ChangePeerRequest `protobuf:"bytes,2,opt,name=change_peer,json=changePeer" json:"change_peer,omitempty"` Split *SplitRequest `protobuf:"bytes,3,opt,name=split" json:"split,omitempty"` // Deprecated: Do not use. CompactLog *CompactLogRequest `protobuf:"bytes,4,opt,name=compact_log,json=compactLog" json:"compact_log,omitempty"` TransferLeader *TransferLeaderRequest `protobuf:"bytes,5,opt,name=transfer_leader,json=transferLeader" json:"transfer_leader,omitempty"` VerifyHash *VerifyHashRequest `protobuf:"bytes,6,opt,name=verify_hash,json=verifyHash" json:"verify_hash,omitempty"` PrepareMerge *PrepareMergeRequest `protobuf:"bytes,7,opt,name=prepare_merge,json=prepareMerge" json:"prepare_merge,omitempty"` CommitMerge *CommitMergeRequest `protobuf:"bytes,8,opt,name=commit_merge,json=commitMerge" json:"commit_merge,omitempty"` RollbackMerge *RollbackMergeRequest `protobuf:"bytes,9,opt,name=rollback_merge,json=rollbackMerge" json:"rollback_merge,omitempty"` Splits *BatchSplitRequest `protobuf:"bytes,10,opt,name=splits" json:"splits,omitempty"` ChangePeerV2 *ChangePeerV2Request `protobuf:"bytes,11,opt,name=change_peer_v2,json=changePeerV2" json:"change_peer_v2,omitempty"` ComputeHash *ComputeHashRequest `protobuf:"bytes,12,opt,name=compute_hash,json=computeHash" json:"compute_hash,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AdminRequest) Reset() { *m = AdminRequest{} } func (m *AdminRequest) String() string { return proto.CompactTextString(m) } func (*AdminRequest) ProtoMessage() {} func (*AdminRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{39} } func (m *AdminRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AdminRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AdminRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AdminRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AdminRequest.Merge(dst, src) } func (m *AdminRequest) XXX_Size() int { return m.Size() } func (m *AdminRequest) XXX_DiscardUnknown() { xxx_messageInfo_AdminRequest.DiscardUnknown(m) } var xxx_messageInfo_AdminRequest proto.InternalMessageInfo func (m *AdminRequest) GetCmdType() AdminCmdType { if m != nil { return m.CmdType } return AdminCmdType_InvalidAdmin } func (m *AdminRequest) GetChangePeer() *ChangePeerRequest { if m != nil { return m.ChangePeer } return nil } // Deprecated: Do not use. func (m *AdminRequest) GetSplit() *SplitRequest { if m != nil { return m.Split } return nil } func (m *AdminRequest) GetCompactLog() *CompactLogRequest { if m != nil { return m.CompactLog } return nil } func (m *AdminRequest) GetTransferLeader() *TransferLeaderRequest { if m != nil { return m.TransferLeader } return nil } func (m *AdminRequest) GetVerifyHash() *VerifyHashRequest { if m != nil { return m.VerifyHash } return nil } func (m *AdminRequest) GetPrepareMerge() *PrepareMergeRequest { if m != nil { return m.PrepareMerge } return nil } func (m *AdminRequest) GetCommitMerge() *CommitMergeRequest { if m != nil { return m.CommitMerge } return nil } func (m *AdminRequest) GetRollbackMerge() *RollbackMergeRequest { if m != nil { return m.RollbackMerge } return nil } func (m *AdminRequest) GetSplits() *BatchSplitRequest { if m != nil { return m.Splits } return nil } func (m *AdminRequest) GetChangePeerV2() *ChangePeerV2Request { if m != nil { return m.ChangePeerV2 } return nil } func (m *AdminRequest) GetComputeHash() *ComputeHashRequest { if m != nil { return m.ComputeHash } return nil } type AdminResponse struct { CmdType AdminCmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.AdminCmdType" json:"cmd_type,omitempty"` ChangePeer *ChangePeerResponse `protobuf:"bytes,2,opt,name=change_peer,json=changePeer" json:"change_peer,omitempty"` Split *SplitResponse `protobuf:"bytes,3,opt,name=split" json:"split,omitempty"` // Deprecated: Do not use. CompactLog *CompactLogResponse `protobuf:"bytes,4,opt,name=compact_log,json=compactLog" json:"compact_log,omitempty"` TransferLeader *TransferLeaderResponse `protobuf:"bytes,5,opt,name=transfer_leader,json=transferLeader" json:"transfer_leader,omitempty"` VerifyHash *VerifyHashResponse `protobuf:"bytes,6,opt,name=verify_hash,json=verifyHash" json:"verify_hash,omitempty"` PrepareMerge *PrepareMergeResponse `protobuf:"bytes,7,opt,name=prepare_merge,json=prepareMerge" json:"prepare_merge,omitempty"` CommitMerge *CommitMergeResponse `protobuf:"bytes,8,opt,name=commit_merge,json=commitMerge" json:"commit_merge,omitempty"` RollbackMerge *RollbackMergeResponse `protobuf:"bytes,9,opt,name=rollback_merge,json=rollbackMerge" json:"rollback_merge,omitempty"` Splits *BatchSplitResponse `protobuf:"bytes,10,opt,name=splits" json:"splits,omitempty"` ChangePeerV2 *ChangePeerV2Response `protobuf:"bytes,11,opt,name=change_peer_v2,json=changePeerV2" json:"change_peer_v2,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AdminResponse) Reset() { *m = AdminResponse{} } func (m *AdminResponse) String() string { return proto.CompactTextString(m) } func (*AdminResponse) ProtoMessage() {} func (*AdminResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{40} } func (m *AdminResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AdminResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *AdminResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_AdminResponse.Merge(dst, src) } func (m *AdminResponse) XXX_Size() int { return m.Size() } func (m *AdminResponse) XXX_DiscardUnknown() { xxx_messageInfo_AdminResponse.DiscardUnknown(m) } var xxx_messageInfo_AdminResponse proto.InternalMessageInfo func (m *AdminResponse) GetCmdType() AdminCmdType { if m != nil { return m.CmdType } return AdminCmdType_InvalidAdmin } func (m *AdminResponse) GetChangePeer() *ChangePeerResponse { if m != nil { return m.ChangePeer } return nil } // Deprecated: Do not use. func (m *AdminResponse) GetSplit() *SplitResponse { if m != nil { return m.Split } return nil } func (m *AdminResponse) GetCompactLog() *CompactLogResponse { if m != nil { return m.CompactLog } return nil } func (m *AdminResponse) GetTransferLeader() *TransferLeaderResponse { if m != nil { return m.TransferLeader } return nil } func (m *AdminResponse) GetVerifyHash() *VerifyHashResponse { if m != nil { return m.VerifyHash } return nil } func (m *AdminResponse) GetPrepareMerge() *PrepareMergeResponse { if m != nil { return m.PrepareMerge } return nil } func (m *AdminResponse) GetCommitMerge() *CommitMergeResponse { if m != nil { return m.CommitMerge } return nil } func (m *AdminResponse) GetRollbackMerge() *RollbackMergeResponse { if m != nil { return m.RollbackMerge } return nil } func (m *AdminResponse) GetSplits() *BatchSplitResponse { if m != nil { return m.Splits } return nil } func (m *AdminResponse) GetChangePeerV2() *ChangePeerV2Response { if m != nil { return m.ChangePeerV2 } return nil } // For get the leader of the region. type RegionLeaderRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionLeaderRequest) Reset() { *m = RegionLeaderRequest{} } func (m *RegionLeaderRequest) String() string { return proto.CompactTextString(m) } func (*RegionLeaderRequest) ProtoMessage() {} func (*RegionLeaderRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{41} } func (m *RegionLeaderRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionLeaderRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionLeaderRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionLeaderRequest.Merge(dst, src) } func (m *RegionLeaderRequest) XXX_Size() int { return m.Size() } func (m *RegionLeaderRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionLeaderRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionLeaderRequest proto.InternalMessageInfo type RegionLeaderResponse struct { Leader *metapb.Peer `protobuf:"bytes,1,opt,name=leader" json:"leader,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionLeaderResponse) Reset() { *m = RegionLeaderResponse{} } func (m *RegionLeaderResponse) String() string { return proto.CompactTextString(m) } func (*RegionLeaderResponse) ProtoMessage() {} func (*RegionLeaderResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{42} } func (m *RegionLeaderResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionLeaderResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionLeaderResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionLeaderResponse.Merge(dst, src) } func (m *RegionLeaderResponse) XXX_Size() int { return m.Size() } func (m *RegionLeaderResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionLeaderResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionLeaderResponse proto.InternalMessageInfo func (m *RegionLeaderResponse) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } // For getting more information of the region. // We add some admin operations (ChangePeer, Split...) into the pb job list, // then pd server will peek the first one, handle it and then pop it from the job lib. // But sometimes, the pd server may crash before popping. When another pd server // starts and finds the job is running but not finished, it will first check whether // the raft server already has handled this job. // E,g, for ChangePeer, if we add Peer10 into region1 and find region1 has already had // Peer10, we can think this ChangePeer is finished, and can pop this job from job list // directly. type RegionDetailRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionDetailRequest) Reset() { *m = RegionDetailRequest{} } func (m *RegionDetailRequest) String() string { return proto.CompactTextString(m) } func (*RegionDetailRequest) ProtoMessage() {} func (*RegionDetailRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{43} } func (m *RegionDetailRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionDetailRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionDetailRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionDetailRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionDetailRequest.Merge(dst, src) } func (m *RegionDetailRequest) XXX_Size() int { return m.Size() } func (m *RegionDetailRequest) XXX_DiscardUnknown() { xxx_messageInfo_RegionDetailRequest.DiscardUnknown(m) } var xxx_messageInfo_RegionDetailRequest proto.InternalMessageInfo type RegionDetailResponse struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` Leader *metapb.Peer `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionDetailResponse) Reset() { *m = RegionDetailResponse{} } func (m *RegionDetailResponse) String() string { return proto.CompactTextString(m) } func (*RegionDetailResponse) ProtoMessage() {} func (*RegionDetailResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{44} } func (m *RegionDetailResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionDetailResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionDetailResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionDetailResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionDetailResponse.Merge(dst, src) } func (m *RegionDetailResponse) XXX_Size() int { return m.Size() } func (m *RegionDetailResponse) XXX_DiscardUnknown() { xxx_messageInfo_RegionDetailResponse.DiscardUnknown(m) } var xxx_messageInfo_RegionDetailResponse proto.InternalMessageInfo func (m *RegionDetailResponse) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *RegionDetailResponse) GetLeader() *metapb.Peer { if m != nil { return m.Leader } return nil } type StatusRequest struct { CmdType StatusCmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.StatusCmdType" json:"cmd_type,omitempty"` RegionLeader *RegionLeaderRequest `protobuf:"bytes,2,opt,name=region_leader,json=regionLeader" json:"region_leader,omitempty"` RegionDetail *RegionDetailRequest `protobuf:"bytes,3,opt,name=region_detail,json=regionDetail" json:"region_detail,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatusRequest) Reset() { *m = StatusRequest{} } func (m *StatusRequest) String() string { return proto.CompactTextString(m) } func (*StatusRequest) ProtoMessage() {} func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{45} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusRequest.Merge(dst, 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 func (m *StatusRequest) GetCmdType() StatusCmdType { if m != nil { return m.CmdType } return StatusCmdType_InvalidStatus } func (m *StatusRequest) GetRegionLeader() *RegionLeaderRequest { if m != nil { return m.RegionLeader } return nil } func (m *StatusRequest) GetRegionDetail() *RegionDetailRequest { if m != nil { return m.RegionDetail } return nil } type StatusResponse struct { CmdType StatusCmdType `protobuf:"varint,1,opt,name=cmd_type,json=cmdType,proto3,enum=raft_cmdpb.StatusCmdType" json:"cmd_type,omitempty"` RegionLeader *RegionLeaderResponse `protobuf:"bytes,2,opt,name=region_leader,json=regionLeader" json:"region_leader,omitempty"` RegionDetail *RegionDetailResponse `protobuf:"bytes,3,opt,name=region_detail,json=regionDetail" json:"region_detail,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatusResponse) Reset() { *m = StatusResponse{} } func (m *StatusResponse) String() string { return proto.CompactTextString(m) } func (*StatusResponse) ProtoMessage() {} func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{46} } 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.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusResponse.Merge(dst, 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 func (m *StatusResponse) GetCmdType() StatusCmdType { if m != nil { return m.CmdType } return StatusCmdType_InvalidStatus } func (m *StatusResponse) GetRegionLeader() *RegionLeaderResponse { if m != nil { return m.RegionLeader } return nil } func (m *StatusResponse) GetRegionDetail() *RegionDetailResponse { if m != nil { return m.RegionDetail } return nil } type RaftRequestHeader struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` Peer *metapb.Peer `protobuf:"bytes,2,opt,name=peer" json:"peer,omitempty"` // true for read linearization ReadQuorum bool `protobuf:"varint,3,opt,name=read_quorum,json=readQuorum,proto3" json:"read_quorum,omitempty"` // 16 bytes, to distinguish request. Uuid []byte `protobuf:"bytes,4,opt,name=uuid,proto3" json:"uuid,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,5,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` Term uint64 `protobuf:"varint,6,opt,name=term,proto3" json:"term,omitempty"` SyncLog bool `protobuf:"varint,7,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` ReplicaRead bool `protobuf:"varint,8,opt,name=replica_read,json=replicaRead,proto3" json:"replica_read,omitempty"` // Read requests can be responsed directly after the Raft applys to `applied_index`. AppliedIndex uint64 `protobuf:"varint,9,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` // Custom flags for this raft request. Flags uint64 `protobuf:"varint,10,opt,name=flags,proto3" json:"flags,omitempty"` FlagData []byte `protobuf:"bytes,11,opt,name=flag_data,json=flagData,proto3" json:"flag_data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftRequestHeader) Reset() { *m = RaftRequestHeader{} } func (m *RaftRequestHeader) String() string { return proto.CompactTextString(m) } func (*RaftRequestHeader) ProtoMessage() {} func (*RaftRequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{47} } func (m *RaftRequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftRequestHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftRequestHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftRequestHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftRequestHeader.Merge(dst, src) } func (m *RaftRequestHeader) XXX_Size() int { return m.Size() } func (m *RaftRequestHeader) XXX_DiscardUnknown() { xxx_messageInfo_RaftRequestHeader.DiscardUnknown(m) } var xxx_messageInfo_RaftRequestHeader proto.InternalMessageInfo func (m *RaftRequestHeader) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RaftRequestHeader) GetPeer() *metapb.Peer { if m != nil { return m.Peer } return nil } func (m *RaftRequestHeader) GetReadQuorum() bool { if m != nil { return m.ReadQuorum } return false } func (m *RaftRequestHeader) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *RaftRequestHeader) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *RaftRequestHeader) GetTerm() uint64 { if m != nil { return m.Term } return 0 } func (m *RaftRequestHeader) GetSyncLog() bool { if m != nil { return m.SyncLog } return false } func (m *RaftRequestHeader) GetReplicaRead() bool { if m != nil { return m.ReplicaRead } return false } func (m *RaftRequestHeader) GetAppliedIndex() uint64 { if m != nil { return m.AppliedIndex } return 0 } func (m *RaftRequestHeader) GetFlags() uint64 { if m != nil { return m.Flags } return 0 } func (m *RaftRequestHeader) GetFlagData() []byte { if m != nil { return m.FlagData } return nil } type RaftResponseHeader struct { Error *errorpb.Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` Uuid []byte `protobuf:"bytes,2,opt,name=uuid,proto3" json:"uuid,omitempty"` CurrentTerm uint64 `protobuf:"varint,3,opt,name=current_term,json=currentTerm,proto3" json:"current_term,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftResponseHeader) Reset() { *m = RaftResponseHeader{} } func (m *RaftResponseHeader) String() string { return proto.CompactTextString(m) } func (*RaftResponseHeader) ProtoMessage() {} func (*RaftResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{48} } func (m *RaftResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftResponseHeader.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftResponseHeader) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftResponseHeader.Merge(dst, src) } func (m *RaftResponseHeader) XXX_Size() int { return m.Size() } func (m *RaftResponseHeader) XXX_DiscardUnknown() { xxx_messageInfo_RaftResponseHeader.DiscardUnknown(m) } var xxx_messageInfo_RaftResponseHeader proto.InternalMessageInfo func (m *RaftResponseHeader) GetError() *errorpb.Error { if m != nil { return m.Error } return nil } func (m *RaftResponseHeader) GetUuid() []byte { if m != nil { return m.Uuid } return nil } func (m *RaftResponseHeader) GetCurrentTerm() uint64 { if m != nil { return m.CurrentTerm } return 0 } type RaftCmdRequest struct { Header *RaftRequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` // We can't enclose normal requests and administrator request // at same time. Requests []*Request `protobuf:"bytes,2,rep,name=requests" json:"requests,omitempty"` AdminRequest *AdminRequest `protobuf:"bytes,3,opt,name=admin_request,json=adminRequest" json:"admin_request,omitempty"` StatusRequest *StatusRequest `protobuf:"bytes,4,opt,name=status_request,json=statusRequest" json:"status_request,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftCmdRequest) Reset() { *m = RaftCmdRequest{} } func (m *RaftCmdRequest) String() string { return proto.CompactTextString(m) } func (*RaftCmdRequest) ProtoMessage() {} func (*RaftCmdRequest) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{49} } func (m *RaftCmdRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftCmdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftCmdRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftCmdRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftCmdRequest.Merge(dst, src) } func (m *RaftCmdRequest) XXX_Size() int { return m.Size() } func (m *RaftCmdRequest) XXX_DiscardUnknown() { xxx_messageInfo_RaftCmdRequest.DiscardUnknown(m) } var xxx_messageInfo_RaftCmdRequest proto.InternalMessageInfo func (m *RaftCmdRequest) GetHeader() *RaftRequestHeader { if m != nil { return m.Header } return nil } func (m *RaftCmdRequest) GetRequests() []*Request { if m != nil { return m.Requests } return nil } func (m *RaftCmdRequest) GetAdminRequest() *AdminRequest { if m != nil { return m.AdminRequest } return nil } func (m *RaftCmdRequest) GetStatusRequest() *StatusRequest { if m != nil { return m.StatusRequest } return nil } type RaftCmdResponse struct { Header *RaftResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` Responses []*Response `protobuf:"bytes,2,rep,name=responses" json:"responses,omitempty"` AdminResponse *AdminResponse `protobuf:"bytes,3,opt,name=admin_response,json=adminResponse" json:"admin_response,omitempty"` StatusResponse *StatusResponse `protobuf:"bytes,4,opt,name=status_response,json=statusResponse" json:"status_response,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftCmdResponse) Reset() { *m = RaftCmdResponse{} } func (m *RaftCmdResponse) String() string { return proto.CompactTextString(m) } func (*RaftCmdResponse) ProtoMessage() {} func (*RaftCmdResponse) Descriptor() ([]byte, []int) { return fileDescriptor_raft_cmdpb_ca66aec18cfe7594, []int{50} } func (m *RaftCmdResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftCmdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftCmdResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftCmdResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftCmdResponse.Merge(dst, src) } func (m *RaftCmdResponse) XXX_Size() int { return m.Size() } func (m *RaftCmdResponse) XXX_DiscardUnknown() { xxx_messageInfo_RaftCmdResponse.DiscardUnknown(m) } var xxx_messageInfo_RaftCmdResponse proto.InternalMessageInfo func (m *RaftCmdResponse) GetHeader() *RaftResponseHeader { if m != nil { return m.Header } return nil } func (m *RaftCmdResponse) GetResponses() []*Response { if m != nil { return m.Responses } return nil } func (m *RaftCmdResponse) GetAdminResponse() *AdminResponse { if m != nil { return m.AdminResponse } return nil } func (m *RaftCmdResponse) GetStatusResponse() *StatusResponse { if m != nil { return m.StatusResponse } return nil } func init() { proto.RegisterType((*GetRequest)(nil), "raft_cmdpb.GetRequest") proto.RegisterType((*GetResponse)(nil), "raft_cmdpb.GetResponse") proto.RegisterType((*PutRequest)(nil), "raft_cmdpb.PutRequest") proto.RegisterType((*PutResponse)(nil), "raft_cmdpb.PutResponse") proto.RegisterType((*DeleteRequest)(nil), "raft_cmdpb.DeleteRequest") proto.RegisterType((*DeleteResponse)(nil), "raft_cmdpb.DeleteResponse") proto.RegisterType((*DeleteRangeRequest)(nil), "raft_cmdpb.DeleteRangeRequest") proto.RegisterType((*DeleteRangeResponse)(nil), "raft_cmdpb.DeleteRangeResponse") proto.RegisterType((*SnapRequest)(nil), "raft_cmdpb.SnapRequest") proto.RegisterType((*SnapResponse)(nil), "raft_cmdpb.SnapResponse") proto.RegisterType((*PrewriteRequest)(nil), "raft_cmdpb.PrewriteRequest") proto.RegisterType((*PrewriteResponse)(nil), "raft_cmdpb.PrewriteResponse") proto.RegisterType((*IngestSSTRequest)(nil), "raft_cmdpb.IngestSSTRequest") proto.RegisterType((*IngestSSTResponse)(nil), "raft_cmdpb.IngestSSTResponse") proto.RegisterType((*ReadIndexRequest)(nil), "raft_cmdpb.ReadIndexRequest") proto.RegisterType((*ReadIndexResponse)(nil), "raft_cmdpb.ReadIndexResponse") proto.RegisterType((*Request)(nil), "raft_cmdpb.Request") proto.RegisterType((*Response)(nil), "raft_cmdpb.Response") proto.RegisterType((*ChangePeerRequest)(nil), "raft_cmdpb.ChangePeerRequest") proto.RegisterType((*ChangePeerResponse)(nil), "raft_cmdpb.ChangePeerResponse") proto.RegisterType((*ChangePeerV2Request)(nil), "raft_cmdpb.ChangePeerV2Request") proto.RegisterType((*ChangePeerV2Response)(nil), "raft_cmdpb.ChangePeerV2Response") proto.RegisterType((*SplitRequest)(nil), "raft_cmdpb.SplitRequest") proto.RegisterType((*SplitResponse)(nil), "raft_cmdpb.SplitResponse") proto.RegisterType((*BatchSplitRequest)(nil), "raft_cmdpb.BatchSplitRequest") proto.RegisterType((*BatchSplitResponse)(nil), "raft_cmdpb.BatchSplitResponse") proto.RegisterType((*CompactLogRequest)(nil), "raft_cmdpb.CompactLogRequest") proto.RegisterType((*CompactLogResponse)(nil), "raft_cmdpb.CompactLogResponse") proto.RegisterType((*TransferLeaderRequest)(nil), "raft_cmdpb.TransferLeaderRequest") proto.RegisterType((*TransferLeaderResponse)(nil), "raft_cmdpb.TransferLeaderResponse") proto.RegisterType((*ComputeHashRequest)(nil), "raft_cmdpb.ComputeHashRequest") proto.RegisterType((*VerifyHashRequest)(nil), "raft_cmdpb.VerifyHashRequest") proto.RegisterType((*VerifyHashResponse)(nil), "raft_cmdpb.VerifyHashResponse") proto.RegisterType((*PrepareMergeRequest)(nil), "raft_cmdpb.PrepareMergeRequest") proto.RegisterType((*PrepareMergeResponse)(nil), "raft_cmdpb.PrepareMergeResponse") proto.RegisterType((*CommitMergeRequest)(nil), "raft_cmdpb.CommitMergeRequest") proto.RegisterType((*CommitMergeResponse)(nil), "raft_cmdpb.CommitMergeResponse") proto.RegisterType((*RollbackMergeRequest)(nil), "raft_cmdpb.RollbackMergeRequest") proto.RegisterType((*RollbackMergeResponse)(nil), "raft_cmdpb.RollbackMergeResponse") proto.RegisterType((*AdminRequest)(nil), "raft_cmdpb.AdminRequest") proto.RegisterType((*AdminResponse)(nil), "raft_cmdpb.AdminResponse") proto.RegisterType((*RegionLeaderRequest)(nil), "raft_cmdpb.RegionLeaderRequest") proto.RegisterType((*RegionLeaderResponse)(nil), "raft_cmdpb.RegionLeaderResponse") proto.RegisterType((*RegionDetailRequest)(nil), "raft_cmdpb.RegionDetailRequest") proto.RegisterType((*RegionDetailResponse)(nil), "raft_cmdpb.RegionDetailResponse") proto.RegisterType((*StatusRequest)(nil), "raft_cmdpb.StatusRequest") proto.RegisterType((*StatusResponse)(nil), "raft_cmdpb.StatusResponse") proto.RegisterType((*RaftRequestHeader)(nil), "raft_cmdpb.RaftRequestHeader") proto.RegisterType((*RaftResponseHeader)(nil), "raft_cmdpb.RaftResponseHeader") proto.RegisterType((*RaftCmdRequest)(nil), "raft_cmdpb.RaftCmdRequest") proto.RegisterType((*RaftCmdResponse)(nil), "raft_cmdpb.RaftCmdResponse") proto.RegisterEnum("raft_cmdpb.CmdType", CmdType_name, CmdType_value) proto.RegisterEnum("raft_cmdpb.AdminCmdType", AdminCmdType_name, AdminCmdType_value) proto.RegisterEnum("raft_cmdpb.StatusCmdType", StatusCmdType_name, StatusCmdType_value) } func (m *GetRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GetResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Value) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PutResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PutResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.Key) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if len(m.StartKey) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.NotifyOnly { dAtA[i] = 0x20 i++ if m.NotifyOnly { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Region.Size())) n1, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrewriteRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrewriteRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if len(m.Lock) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Lock))) i += copy(dAtA[i:], m.Lock) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrewriteResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrewriteResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IngestSSTRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IngestSSTRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Sst != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Sst.Size())) n2, err := m.Sst.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *IngestSSTResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *IngestSSTResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadIndexRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadIndexRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.StartTs)) } if len(m.KeyRanges) > 0 { for _, msg := range m.KeyRanges { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ReadIndexResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReadIndexResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ReadIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ReadIndex)) } if m.Locked != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Locked.Size())) n3, err := m.Locked.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Request) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Request) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.Get != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Get.Size())) n4, err := m.Get.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.Put != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Put.Size())) n5, err := m.Put.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.Delete != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Delete.Size())) n6, err := m.Delete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if m.Snap != nil { dAtA[i] = 0x32 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Snap.Size())) n7, err := m.Snap.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if m.Prewrite != nil { dAtA[i] = 0x3a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Prewrite.Size())) n8, err := m.Prewrite.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.DeleteRange != nil { dAtA[i] = 0x42 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.DeleteRange.Size())) n9, err := m.DeleteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.IngestSst != nil { dAtA[i] = 0x4a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.IngestSst.Size())) n10, err := m.IngestSst.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.ReadIndex != nil { dAtA[i] = 0x52 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ReadIndex.Size())) n11, err := m.ReadIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Response) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Response) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.Get != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Get.Size())) n12, err := m.Get.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.Put != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Put.Size())) n13, err := m.Put.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.Delete != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Delete.Size())) n14, err := m.Delete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if m.Snap != nil { dAtA[i] = 0x32 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Snap.Size())) n15, err := m.Snap.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } if m.Prewrite != nil { dAtA[i] = 0x3a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Prewrite.Size())) n16, err := m.Prewrite.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } if m.DelteRange != nil { dAtA[i] = 0x42 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.DelteRange.Size())) n17, err := m.DelteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } if m.IngestSst != nil { dAtA[i] = 0x4a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.IngestSst.Size())) n18, err := m.IngestSst.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } if m.ReadIndex != nil { dAtA[i] = 0x52 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ReadIndex.Size())) n19, err := m.ReadIndex.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeerRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ChangeType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ChangeType)) } if m.Peer != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Peer.Size())) n20, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeerResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Region.Size())) n21, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeerV2Request) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeerV2Request) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Changes) > 0 { for _, msg := range m.Changes { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ChangePeerV2Response) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ChangePeerV2Response) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Region.Size())) n22, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.SplitKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.SplitKey))) i += copy(dAtA[i:], m.SplitKey) } if m.NewRegionId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { dAtA24 := make([]byte, len(m.NewPeerIds)*10) var j23 int for _, num := range m.NewPeerIds { for num >= 1<<7 { dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j23++ } dAtA24[j23] = uint8(num) j23++ } dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(j23)) i += copy(dAtA[i:], dAtA24[:j23]) } if m.RightDerive { dAtA[i] = 0x20 i++ if m.RightDerive { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Left != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Left.Size())) n25, err := m.Left.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } if m.Right != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Right.Size())) n26, err := m.Right.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Requests) > 0 { for _, msg := range m.Requests { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.RightDerive { dAtA[i] = 0x10 i++ if m.RightDerive { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Regions) > 0 { for _, msg := range m.Regions { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactLogRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactLogRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CompactIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CompactIndex)) } if m.CompactTerm != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CompactTerm)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CompactLogResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CompactLogResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TransferLeaderRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TransferLeaderRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Peer != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Peer.Size())) n27, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } if len(m.Peers) > 0 { for _, msg := range m.Peers { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TransferLeaderResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TransferLeaderResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ComputeHashRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ComputeHashRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Context) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *VerifyHashRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *VerifyHashRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Index != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Index)) } if len(m.Hash) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Hash))) i += copy(dAtA[i:], m.Hash) } if len(m.Context) > 0 { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *VerifyHashResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *VerifyHashResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrepareMergeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrepareMergeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.MinIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.MinIndex)) } if m.Target != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Target.Size())) n28, err := m.Target.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n28 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *PrepareMergeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrepareMergeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitMergeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitMergeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Source != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Source.Size())) n29, err := m.Source.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n29 } if m.Commit != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Commit)) } if len(m.Entries) > 0 { for _, msg := range m.Entries { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *CommitMergeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *CommitMergeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RollbackMergeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RollbackMergeRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Commit != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Commit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RollbackMergeResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RollbackMergeResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AdminRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AdminRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.ChangePeer != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ChangePeer.Size())) n30, err := m.ChangePeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n30 } if m.Split != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Split.Size())) n31, err := m.Split.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n31 } if m.CompactLog != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CompactLog.Size())) n32, err := m.CompactLog.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n32 } if m.TransferLeader != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.TransferLeader.Size())) n33, err := m.TransferLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n33 } if m.VerifyHash != nil { dAtA[i] = 0x32 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.VerifyHash.Size())) n34, err := m.VerifyHash.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n34 } if m.PrepareMerge != nil { dAtA[i] = 0x3a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.PrepareMerge.Size())) n35, err := m.PrepareMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n35 } if m.CommitMerge != nil { dAtA[i] = 0x42 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CommitMerge.Size())) n36, err := m.CommitMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n36 } if m.RollbackMerge != nil { dAtA[i] = 0x4a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RollbackMerge.Size())) n37, err := m.RollbackMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n37 } if m.Splits != nil { dAtA[i] = 0x52 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Splits.Size())) n38, err := m.Splits.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n38 } if m.ChangePeerV2 != nil { dAtA[i] = 0x5a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ChangePeerV2.Size())) n39, err := m.ChangePeerV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n39 } if m.ComputeHash != nil { dAtA[i] = 0x62 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ComputeHash.Size())) n40, err := m.ComputeHash.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n40 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *AdminResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *AdminResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.ChangePeer != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ChangePeer.Size())) n41, err := m.ChangePeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n41 } if m.Split != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Split.Size())) n42, err := m.Split.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n42 } if m.CompactLog != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CompactLog.Size())) n43, err := m.CompactLog.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n43 } if m.TransferLeader != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.TransferLeader.Size())) n44, err := m.TransferLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n44 } if m.VerifyHash != nil { dAtA[i] = 0x32 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.VerifyHash.Size())) n45, err := m.VerifyHash.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n45 } if m.PrepareMerge != nil { dAtA[i] = 0x3a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.PrepareMerge.Size())) n46, err := m.PrepareMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n46 } if m.CommitMerge != nil { dAtA[i] = 0x42 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CommitMerge.Size())) n47, err := m.CommitMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n47 } if m.RollbackMerge != nil { dAtA[i] = 0x4a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RollbackMerge.Size())) n48, err := m.RollbackMerge.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n48 } if m.Splits != nil { dAtA[i] = 0x52 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Splits.Size())) n49, err := m.Splits.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n49 } if m.ChangePeerV2 != nil { dAtA[i] = 0x5a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.ChangePeerV2.Size())) n50, err := m.ChangePeerV2.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n50 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionLeaderRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionLeaderRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionLeaderResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionLeaderResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Leader != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Leader.Size())) n51, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n51 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionDetailRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionDetailRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionDetailResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionDetailResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Region.Size())) n52, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n52 } if m.Leader != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Leader.Size())) n53, err := m.Leader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n53 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StatusRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.RegionLeader != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionLeader.Size())) n54, err := m.RegionLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n54 } if m.RegionDetail != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionDetail.Size())) n55, err := m.RegionDetail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n55 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.CmdType != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CmdType)) } if m.RegionLeader != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionLeader.Size())) n56, err := m.RegionLeader.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n56 } if m.RegionDetail != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionDetail.Size())) n57, err := m.RegionDetail.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n57 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftRequestHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftRequestHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionId)) } if m.Peer != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Peer.Size())) n58, err := m.Peer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n58 } if m.ReadQuorum { dAtA[i] = 0x18 i++ if m.ReadQuorum { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.Uuid) > 0 { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.RegionEpoch != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.RegionEpoch.Size())) n59, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n59 } if m.Term != 0 { dAtA[i] = 0x30 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Term)) } if m.SyncLog { dAtA[i] = 0x38 i++ if m.SyncLog { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.ReplicaRead { dAtA[i] = 0x40 i++ if m.ReplicaRead { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.AppliedIndex != 0 { dAtA[i] = 0x48 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.AppliedIndex)) } if m.Flags != 0 { dAtA[i] = 0x50 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Flags)) } if len(m.FlagData) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.FlagData))) i += copy(dAtA[i:], m.FlagData) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftResponseHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftResponseHeader) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Error != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Error.Size())) n60, err := m.Error.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n60 } if len(m.Uuid) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(len(m.Uuid))) i += copy(dAtA[i:], m.Uuid) } if m.CurrentTerm != 0 { dAtA[i] = 0x18 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.CurrentTerm)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftCmdRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftCmdRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Header.Size())) n61, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n61 } if len(m.Requests) > 0 { for _, msg := range m.Requests { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.AdminRequest != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.AdminRequest.Size())) n62, err := m.AdminRequest.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n62 } if m.StatusRequest != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.StatusRequest.Size())) n63, err := m.StatusRequest.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n63 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftCmdResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftCmdResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Header != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.Header.Size())) n64, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n64 } if len(m.Responses) > 0 { for _, msg := range m.Responses { dAtA[i] = 0x12 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.AdminResponse != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.AdminResponse.Size())) n65, err := m.AdminResponse.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n65 } if m.StatusResponse != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftCmdpb(dAtA, i, uint64(m.StatusResponse.Size())) n66, err := m.StatusResponse.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n66 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintRaftCmdpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *GetRequest) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GetResponse) Size() (n int) { var l int _ = l l = len(m.Value) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutRequest) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PutResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRequest) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Key) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRangeRequest) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.StartKey) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.NotifyOnly { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DeleteRangeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapResponse) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrewriteRequest) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Lock) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrewriteResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IngestSSTRequest) Size() (n int) { var l int _ = l if m.Sst != nil { l = m.Sst.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *IngestSSTResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadIndexRequest) Size() (n int) { var l int _ = l if m.StartTs != 0 { n += 1 + sovRaftCmdpb(uint64(m.StartTs)) } if len(m.KeyRanges) > 0 { for _, e := range m.KeyRanges { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ReadIndexResponse) Size() (n int) { var l int _ = l if m.ReadIndex != 0 { n += 1 + sovRaftCmdpb(uint64(m.ReadIndex)) } if m.Locked != nil { l = m.Locked.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Request) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.Get != nil { l = m.Get.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Put != nil { l = m.Put.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Delete != nil { l = m.Delete.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Snap != nil { l = m.Snap.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Prewrite != nil { l = m.Prewrite.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.DeleteRange != nil { l = m.DeleteRange.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.IngestSst != nil { l = m.IngestSst.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ReadIndex != nil { l = m.ReadIndex.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Response) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.Get != nil { l = m.Get.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Put != nil { l = m.Put.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Delete != nil { l = m.Delete.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Snap != nil { l = m.Snap.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Prewrite != nil { l = m.Prewrite.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.DelteRange != nil { l = m.DelteRange.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.IngestSst != nil { l = m.IngestSst.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ReadIndex != nil { l = m.ReadIndex.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeerRequest) Size() (n int) { var l int _ = l if m.ChangeType != 0 { n += 1 + sovRaftCmdpb(uint64(m.ChangeType)) } if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeerResponse) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeerV2Request) Size() (n int) { var l int _ = l if len(m.Changes) > 0 { for _, e := range m.Changes { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ChangePeerV2Response) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitRequest) Size() (n int) { var l int _ = l l = len(m.SplitKey) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.NewRegionId != 0 { n += 1 + sovRaftCmdpb(uint64(m.NewRegionId)) } if len(m.NewPeerIds) > 0 { l = 0 for _, e := range m.NewPeerIds { l += sovRaftCmdpb(uint64(e)) } n += 1 + sovRaftCmdpb(uint64(l)) + l } if m.RightDerive { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SplitResponse) Size() (n int) { var l int _ = l if m.Left != nil { l = m.Left.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Right != nil { l = m.Right.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchSplitRequest) Size() (n int) { var l int _ = l if len(m.Requests) > 0 { for _, e := range m.Requests { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.RightDerive { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchSplitResponse) Size() (n int) { var l int _ = l if len(m.Regions) > 0 { for _, e := range m.Regions { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactLogRequest) Size() (n int) { var l int _ = l if m.CompactIndex != 0 { n += 1 + sovRaftCmdpb(uint64(m.CompactIndex)) } if m.CompactTerm != 0 { n += 1 + sovRaftCmdpb(uint64(m.CompactTerm)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CompactLogResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TransferLeaderRequest) Size() (n int) { var l int _ = l if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if len(m.Peers) > 0 { for _, e := range m.Peers { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TransferLeaderResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ComputeHashRequest) Size() (n int) { var l int _ = l l = len(m.Context) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *VerifyHashRequest) Size() (n int) { var l int _ = l if m.Index != 0 { n += 1 + sovRaftCmdpb(uint64(m.Index)) } l = len(m.Hash) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Context) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *VerifyHashResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrepareMergeRequest) Size() (n int) { var l int _ = l if m.MinIndex != 0 { n += 1 + sovRaftCmdpb(uint64(m.MinIndex)) } if m.Target != nil { l = m.Target.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *PrepareMergeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitMergeRequest) Size() (n int) { var l int _ = l if m.Source != nil { l = m.Source.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Commit != 0 { n += 1 + sovRaftCmdpb(uint64(m.Commit)) } if len(m.Entries) > 0 { for _, e := range m.Entries { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *CommitMergeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RollbackMergeRequest) Size() (n int) { var l int _ = l if m.Commit != 0 { n += 1 + sovRaftCmdpb(uint64(m.Commit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RollbackMergeResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AdminRequest) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.ChangePeer != nil { l = m.ChangePeer.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Split != nil { l = m.Split.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.CompactLog != nil { l = m.CompactLog.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.TransferLeader != nil { l = m.TransferLeader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.VerifyHash != nil { l = m.VerifyHash.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.PrepareMerge != nil { l = m.PrepareMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.CommitMerge != nil { l = m.CommitMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.RollbackMerge != nil { l = m.RollbackMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Splits != nil { l = m.Splits.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ChangePeerV2 != nil { l = m.ChangePeerV2.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ComputeHash != nil { l = m.ComputeHash.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *AdminResponse) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.ChangePeer != nil { l = m.ChangePeer.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Split != nil { l = m.Split.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.CompactLog != nil { l = m.CompactLog.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.TransferLeader != nil { l = m.TransferLeader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.VerifyHash != nil { l = m.VerifyHash.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.PrepareMerge != nil { l = m.PrepareMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.CommitMerge != nil { l = m.CommitMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.RollbackMerge != nil { l = m.RollbackMerge.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Splits != nil { l = m.Splits.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ChangePeerV2 != nil { l = m.ChangePeerV2.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionLeaderRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionLeaderResponse) Size() (n int) { var l int _ = l if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionDetailRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionDetailResponse) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Leader != nil { l = m.Leader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatusRequest) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.RegionLeader != nil { l = m.RegionLeader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.RegionDetail != nil { l = m.RegionDetail.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StatusResponse) Size() (n int) { var l int _ = l if m.CmdType != 0 { n += 1 + sovRaftCmdpb(uint64(m.CmdType)) } if m.RegionLeader != nil { l = m.RegionLeader.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.RegionDetail != nil { l = m.RegionDetail.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftRequestHeader) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovRaftCmdpb(uint64(m.RegionId)) } if m.Peer != nil { l = m.Peer.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.ReadQuorum { n += 2 } l = len(m.Uuid) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.Term != 0 { n += 1 + sovRaftCmdpb(uint64(m.Term)) } if m.SyncLog { n += 2 } if m.ReplicaRead { n += 2 } if m.AppliedIndex != 0 { n += 1 + sovRaftCmdpb(uint64(m.AppliedIndex)) } if m.Flags != 0 { n += 1 + sovRaftCmdpb(uint64(m.Flags)) } l = len(m.FlagData) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftResponseHeader) Size() (n int) { var l int _ = l if m.Error != nil { l = m.Error.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } l = len(m.Uuid) if l > 0 { n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.CurrentTerm != 0 { n += 1 + sovRaftCmdpb(uint64(m.CurrentTerm)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftCmdRequest) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if len(m.Requests) > 0 { for _, e := range m.Requests { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.AdminRequest != nil { l = m.AdminRequest.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.StatusRequest != nil { l = m.StatusRequest.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftCmdResponse) Size() (n int) { var l int _ = l if m.Header != nil { l = m.Header.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if len(m.Responses) > 0 { for _, e := range m.Responses { l = e.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } } if m.AdminResponse != nil { l = m.AdminResponse.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.StatusResponse != nil { l = m.StatusResponse.Size() n += 1 + l + sovRaftCmdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovRaftCmdpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozRaftCmdpb(x uint64) (n int) { return sovRaftCmdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } 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 ErrIntOverflowRaftCmdpb } 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 Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } 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 ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 ErrIntOverflowRaftCmdpb } 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 Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PutRequest) 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 ErrIntOverflowRaftCmdpb } 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: PutRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } 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 ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PutResponse) 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 ErrIntOverflowRaftCmdpb } 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: PutResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PutResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 ErrIntOverflowRaftCmdpb } 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 Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } 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 ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 ErrIntOverflowRaftCmdpb } 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 { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *DeleteRangeRequest) 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 ErrIntOverflowRaftCmdpb } 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: DeleteRangeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } 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 ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NotifyOnly", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.NotifyOnly = bool(v != 0) default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *DeleteRangeResponse) 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 ErrIntOverflowRaftCmdpb } 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: DeleteRangeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *SnapRequest) 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 ErrIntOverflowRaftCmdpb } 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: SnapRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *SnapResponse) 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 ErrIntOverflowRaftCmdpb } 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: SnapResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PrewriteRequest) 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 ErrIntOverflowRaftCmdpb } 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: PrewriteRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrewriteRequest: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Lock = append(m.Lock[:0], dAtA[iNdEx:postIndex]...) if m.Lock == nil { m.Lock = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PrewriteResponse) 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 ErrIntOverflowRaftCmdpb } 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: PrewriteResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrewriteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *IngestSSTRequest) 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 ErrIntOverflowRaftCmdpb } 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: IngestSSTRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IngestSSTRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Sst == nil { m.Sst = &import_sstpb.SSTMeta{} } if err := m.Sst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *IngestSSTResponse) 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 ErrIntOverflowRaftCmdpb } 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: IngestSSTResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: IngestSSTResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ReadIndexRequest) 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 ErrIntOverflowRaftCmdpb } 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: ReadIndexRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) } m.StartTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field KeyRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.KeyRanges = append(m.KeyRanges, &kvrpcpb.KeyRange{}) if err := m.KeyRanges[len(m.KeyRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ReadIndexResponse) 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 ErrIntOverflowRaftCmdpb } 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: ReadIndexResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReadIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIndex", wireType) } m.ReadIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Locked", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Locked == nil { m.Locked = &kvrpcpb.LockInfo{} } if err := m.Locked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *Request) 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 ErrIntOverflowRaftCmdpb } 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: Request: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (CmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Get == nil { m.Get = &GetRequest{} } if err := m.Get.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Put == nil { m.Put = &PutRequest{} } if err := m.Put.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Delete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Delete == nil { m.Delete = &DeleteRequest{} } if err := m.Delete.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Snap == nil { m.Snap = &SnapRequest{} } if err := m.Snap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Prewrite == nil { m.Prewrite = &PrewriteRequest{} } if err := m.Prewrite.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DeleteRange == nil { m.DeleteRange = &DeleteRangeRequest{} } if err := m.DeleteRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field IngestSst", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.IngestSst == nil { m.IngestSst = &IngestSSTRequest{} } if err := m.IngestSst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReadIndex == nil { m.ReadIndex = &ReadIndexRequest{} } if err := m.ReadIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *Response) 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 ErrIntOverflowRaftCmdpb } 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: Response: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (CmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Get == nil { m.Get = &GetResponse{} } if err := m.Get.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Put == nil { m.Put = &PutResponse{} } if err := m.Put.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Delete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Delete == nil { m.Delete = &DeleteResponse{} } if err := m.Delete.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Snap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Snap == nil { m.Snap = &SnapResponse{} } if err := m.Snap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Prewrite == nil { m.Prewrite = &PrewriteResponse{} } if err := m.Prewrite.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DelteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DelteRange == nil { m.DelteRange = &DeleteRangeResponse{} } if err := m.DelteRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field IngestSst", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.IngestSst == nil { m.IngestSst = &IngestSSTResponse{} } if err := m.IngestSst.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadIndex", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ReadIndex == nil { m.ReadIndex = &ReadIndexResponse{} } if err := m.ReadIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ChangePeerRequest) 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 ErrIntOverflowRaftCmdpb } 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: ChangePeerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) } m.ChangeType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ChangeType |= (eraftpb.ConfChangeType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ChangePeerResponse) 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 ErrIntOverflowRaftCmdpb } 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: ChangePeerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ChangePeerV2Request) 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 ErrIntOverflowRaftCmdpb } 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: ChangePeerV2Request: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeerV2Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Changes = append(m.Changes, &ChangePeerRequest{}) if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ChangePeerV2Response) 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 ErrIntOverflowRaftCmdpb } 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: ChangePeerV2Response: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ChangePeerV2Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *SplitRequest) 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 ErrIntOverflowRaftCmdpb } 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: SplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SplitKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.SplitKey = append(m.SplitKey[:0], dAtA[iNdEx:postIndex]...) if m.SplitKey == nil { m.SplitKey = []byte{} } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) } m.NewRegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.NewRegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.NewPeerIds = append(m.NewPeerIds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RightDerive", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RightDerive = bool(v != 0) default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *SplitResponse) 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 ErrIntOverflowRaftCmdpb } 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: SplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SplitResponse: 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 ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Left == nil { m.Left = &metapb.Region{} } if err := m.Left.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 ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Right == nil { m.Right = &metapb.Region{} } if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *BatchSplitRequest) 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 ErrIntOverflowRaftCmdpb } 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: BatchSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Requests = append(m.Requests, &SplitRequest{}) if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RightDerive", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.RightDerive = bool(v != 0) default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *BatchSplitResponse) 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 ErrIntOverflowRaftCmdpb } 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: BatchSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Regions = append(m.Regions, &metapb.Region{}) if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *CompactLogRequest) 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 ErrIntOverflowRaftCmdpb } 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: CompactLogRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactLogRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompactIndex", wireType) } m.CompactIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompactIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CompactTerm", wireType) } m.CompactTerm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CompactTerm |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *CompactLogResponse) 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 ErrIntOverflowRaftCmdpb } 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: CompactLogResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CompactLogResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *TransferLeaderRequest) 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 ErrIntOverflowRaftCmdpb } 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: TransferLeaderRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TransferLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Peers = append(m.Peers, &metapb.Peer{}) if err := m.Peers[len(m.Peers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *TransferLeaderResponse) 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 ErrIntOverflowRaftCmdpb } 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: TransferLeaderResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TransferLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *ComputeHashRequest) 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 ErrIntOverflowRaftCmdpb } 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: ComputeHashRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ComputeHashRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *VerifyHashRequest) 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 ErrIntOverflowRaftCmdpb } 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: VerifyHashRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: VerifyHashRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) if m.Hash == nil { m.Hash = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) if m.Context == nil { m.Context = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *VerifyHashResponse) 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 ErrIntOverflowRaftCmdpb } 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: VerifyHashResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: VerifyHashResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PrepareMergeRequest) 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 ErrIntOverflowRaftCmdpb } 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: PrepareMergeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrepareMergeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinIndex", wireType) } m.MinIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Target == nil { m.Target = &metapb.Region{} } if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *PrepareMergeResponse) 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 ErrIntOverflowRaftCmdpb } 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: PrepareMergeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrepareMergeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *CommitMergeRequest) 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 ErrIntOverflowRaftCmdpb } 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: CommitMergeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitMergeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Source == nil { m.Source = &metapb.Region{} } if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Entries = append(m.Entries, &eraftpb.Entry{}) if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *CommitMergeResponse) 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 ErrIntOverflowRaftCmdpb } 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: CommitMergeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CommitMergeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RollbackMergeRequest) 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 ErrIntOverflowRaftCmdpb } 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: RollbackMergeRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RollbackMergeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RollbackMergeResponse) 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 ErrIntOverflowRaftCmdpb } 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: RollbackMergeResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RollbackMergeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *AdminRequest) 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 ErrIntOverflowRaftCmdpb } 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: AdminRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AdminRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (AdminCmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeer == nil { m.ChangePeer = &ChangePeerRequest{} } if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Split == nil { m.Split = &SplitRequest{} } if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CompactLog", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CompactLog == nil { m.CompactLog = &CompactLogRequest{} } if err := m.CompactLog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TransferLeader == nil { m.TransferLeader = &TransferLeaderRequest{} } if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field VerifyHash", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.VerifyHash == nil { m.VerifyHash = &VerifyHashRequest{} } if err := m.VerifyHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrepareMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.PrepareMerge == nil { m.PrepareMerge = &PrepareMergeRequest{} } if err := m.PrepareMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CommitMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CommitMerge == nil { m.CommitMerge = &CommitMergeRequest{} } if err := m.CommitMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RollbackMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RollbackMerge == nil { m.RollbackMerge = &RollbackMergeRequest{} } if err := m.RollbackMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Splits", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Splits == nil { m.Splits = &BatchSplitRequest{} } if err := m.Splits.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeerV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeerV2 == nil { m.ChangePeerV2 = &ChangePeerV2Request{} } if err := m.ChangePeerV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ComputeHash", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ComputeHash == nil { m.ComputeHash = &ComputeHashRequest{} } if err := m.ComputeHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *AdminResponse) 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 ErrIntOverflowRaftCmdpb } 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: AdminResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (AdminCmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeer == nil { m.ChangePeer = &ChangePeerResponse{} } if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Split == nil { m.Split = &SplitResponse{} } if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CompactLog", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CompactLog == nil { m.CompactLog = &CompactLogResponse{} } if err := m.CompactLog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TransferLeader == nil { m.TransferLeader = &TransferLeaderResponse{} } if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field VerifyHash", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.VerifyHash == nil { m.VerifyHash = &VerifyHashResponse{} } if err := m.VerifyHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PrepareMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.PrepareMerge == nil { m.PrepareMerge = &PrepareMergeResponse{} } if err := m.PrepareMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CommitMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.CommitMerge == nil { m.CommitMerge = &CommitMergeResponse{} } if err := m.CommitMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RollbackMerge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RollbackMerge == nil { m.RollbackMerge = &RollbackMergeResponse{} } if err := m.RollbackMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Splits", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Splits == nil { m.Splits = &BatchSplitResponse{} } if err := m.Splits.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ChangePeerV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ChangePeerV2 == nil { m.ChangePeerV2 = &ChangePeerV2Response{} } if err := m.ChangePeerV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RegionLeaderRequest) 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 ErrIntOverflowRaftCmdpb } 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: RegionLeaderRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RegionLeaderResponse) 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 ErrIntOverflowRaftCmdpb } 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: RegionLeaderResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RegionDetailRequest) 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 ErrIntOverflowRaftCmdpb } 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: RegionDetailRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionDetailRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RegionDetailResponse) 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 ErrIntOverflowRaftCmdpb } 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: RegionDetailResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionDetailResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Leader == nil { m.Leader = &metapb.Peer{} } if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 ErrIntOverflowRaftCmdpb } 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 != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (StatusCmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionLeader == nil { m.RegionLeader = &RegionLeaderRequest{} } if err := m.RegionLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionDetail", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionDetail == nil { m.RegionDetail = &RegionDetailRequest{} } if err := m.RegionDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 ErrIntOverflowRaftCmdpb } 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 != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CmdType", wireType) } m.CmdType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CmdType |= (StatusCmdType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionLeader == nil { m.RegionLeader = &RegionLeaderResponse{} } if err := m.RegionLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionDetail", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionDetail == nil { m.RegionDetail = &RegionDetailResponse{} } if err := m.RegionDetail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RaftRequestHeader) 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 ErrIntOverflowRaftCmdpb } 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: RaftRequestHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftRequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Peer == nil { m.Peer = &metapb.Peer{} } if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadQuorum", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ReadQuorum = bool(v != 0) case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.SyncLog = bool(v != 0) case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReplicaRead", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ReplicaRead = bool(v != 0) case 9: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType) } m.AppliedIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AppliedIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) } m.Flags = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Flags |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FlagData", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.FlagData = append(m.FlagData[:0], dAtA[iNdEx:postIndex]...) if m.FlagData == nil { m.FlagData = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RaftResponseHeader) 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 ErrIntOverflowRaftCmdpb } 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: RaftResponseHeader: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Error == nil { m.Error = &errorpb.Error{} } if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Uuid = append(m.Uuid[:0], dAtA[iNdEx:postIndex]...) if m.Uuid == nil { m.Uuid = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CurrentTerm", wireType) } m.CurrentTerm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CurrentTerm |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RaftCmdRequest) 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 ErrIntOverflowRaftCmdpb } 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: RaftCmdRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftCmdRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RaftRequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Requests = append(m.Requests, &Request{}) if err := m.Requests[len(m.Requests)-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 AdminRequest", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminRequest == nil { m.AdminRequest = &AdminRequest{} } if err := m.AdminRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StatusRequest", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StatusRequest == nil { m.StatusRequest = &StatusRequest{} } if err := m.StatusRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 *RaftCmdResponse) 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 ErrIntOverflowRaftCmdpb } 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: RaftCmdResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftCmdResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Header == nil { m.Header = &RaftResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Responses = append(m.Responses, &Response{}) if err := m.Responses[len(m.Responses)-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 AdminResponse", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.AdminResponse == nil { m.AdminResponse = &AdminResponse{} } if err := m.AdminResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StatusResponse", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftCmdpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftCmdpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.StatusResponse == nil { m.StatusResponse = &StatusResponse{} } if err := m.StatusResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftCmdpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftCmdpb } 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 skipRaftCmdpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftCmdpb } 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, ErrIntOverflowRaftCmdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftCmdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthRaftCmdpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftCmdpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipRaftCmdpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthRaftCmdpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowRaftCmdpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("raft_cmdpb.proto", fileDescriptor_raft_cmdpb_ca66aec18cfe7594) } var fileDescriptor_raft_cmdpb_ca66aec18cfe7594 = []byte{ // 2333 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x59, 0x5f, 0x6f, 0xdc, 0xc6, 0x11, 0x37, 0xef, 0xff, 0xcd, 0xfd, 0x11, 0xb5, 0x92, 0xad, 0x8b, 0x9d, 0x48, 0x67, 0x26, 0x75, 0x65, 0xb7, 0xb8, 0x36, 0x72, 0xe3, 0x04, 0x88, 0x6b, 0x27, 0x96, 0x14, 0x5b, 0xb5, 0xdd, 0xba, 0x2b, 0x21, 0x45, 0x5b, 0x04, 0x04, 0x4d, 0xee, 0x49, 0x84, 0xee, 0x48, 0x9a, 0xdc, 0x93, 0x73, 0x08, 0xd0, 0xa7, 0x7e, 0x86, 0x22, 0x1f, 0xa1, 0x1f, 0xa5, 0x8f, 0x2d, 0xd0, 0x87, 0x3e, 0x14, 0x45, 0xe1, 0x3c, 0xb5, 0xdf, 0xa0, 0x6f, 0xc5, 0xfe, 0x3b, 0xee, 0xf2, 0x78, 0x4e, 0x9c, 0xa7, 0xdb, 0x9d, 0x9d, 0x9d, 0x99, 0x9d, 0x99, 0xdf, 0xec, 0x2c, 0x0f, 0xec, 0xd4, 0x1b, 0x53, 0xd7, 0x9f, 0x06, 0xc9, 0xf3, 0x51, 0x92, 0xc6, 0x34, 0x46, 0x90, 0x53, 0xae, 0x76, 0xa7, 0x84, 0x7a, 0x6a, 0xe5, 0x6a, 0x8f, 0xa4, 0x69, 0x9c, 0xea, 0x53, 0x6f, 0x4c, 0xf3, 0xe9, 0xf9, 0x45, 0x9a, 0xf8, 0x8b, 0x29, 0x0a, 0xa7, 0x49, 0x9c, 0x52, 0x37, 0xcb, 0x72, 0x96, 0xb5, 0x74, 0x96, 0x51, 0x3e, 0x14, 0x04, 0x67, 0x04, 0xf0, 0x90, 0x50, 0x4c, 0x5e, 0xcc, 0x48, 0x46, 0x51, 0x1f, 0x2a, 0xfe, 0x78, 0x60, 0x0d, 0xad, 0xdd, 0x36, 0xae, 0xf8, 0x63, 0x64, 0x43, 0xf5, 0x9c, 0xcc, 0x07, 0x95, 0xa1, 0xb5, 0xdb, 0xc5, 0x6c, 0xe8, 0xbc, 0x0b, 0x1d, 0xce, 0x9f, 0x25, 0x71, 0x94, 0x11, 0xb4, 0x09, 0xf5, 0x0b, 0x6f, 0x32, 0x23, 0x7c, 0x4f, 0x17, 0x8b, 0x89, 0x73, 0x00, 0xf0, 0x6c, 0xf6, 0xdd, 0x85, 0xe6, 0x52, 0xaa, 0xba, 0x94, 0x1e, 0x74, 0xb8, 0x14, 0xa1, 0xca, 0x79, 0x1f, 0x7a, 0x07, 0x64, 0x42, 0x28, 0xf9, 0xee, 0xc6, 0xda, 0xd0, 0x57, 0x5b, 0xa4, 0x90, 0xaf, 0x00, 0x49, 0x8a, 0x17, 0x9d, 0xae, 0x94, 0x74, 0x0d, 0xda, 0x19, 0xf5, 0x52, 0xea, 0xe6, 0xf2, 0x5a, 0x9c, 0xf0, 0x98, 0xcc, 0xd1, 0x16, 0x34, 0x49, 0x14, 0xf0, 0x25, 0x61, 0x6e, 0x83, 0x44, 0x01, 0x5b, 0xd8, 0x81, 0x4e, 0x14, 0xd3, 0x70, 0x3c, 0x77, 0xe3, 0x68, 0x32, 0x1f, 0xd4, 0x86, 0xd6, 0x6e, 0x0b, 0x83, 0x20, 0xfd, 0x2a, 0x9a, 0xcc, 0x9d, 0xcb, 0xb0, 0x61, 0x28, 0x97, 0x36, 0xf5, 0xa0, 0x73, 0x1c, 0x79, 0x89, 0x34, 0xc6, 0xb9, 0x03, 0x5d, 0x31, 0x95, 0x2e, 0xbe, 0x01, 0x8d, 0x94, 0x9c, 0x86, 0x71, 0xc4, 0x0d, 0xec, 0xec, 0xf5, 0x47, 0x32, 0x25, 0x30, 0xa7, 0x62, 0xb9, 0xea, 0x3c, 0x85, 0xb5, 0x67, 0x29, 0x79, 0x99, 0x86, 0xb9, 0x87, 0xa4, 0x47, 0xac, 0x12, 0x4f, 0x57, 0x34, 0x4f, 0x23, 0x04, 0xb5, 0x49, 0xec, 0x9f, 0xcb, 0xf3, 0xf0, 0xb1, 0x83, 0xc0, 0xce, 0xc5, 0x49, 0x4b, 0x3f, 0x06, 0xfb, 0x28, 0x3a, 0x25, 0x19, 0x3d, 0x3e, 0x3e, 0x51, 0x3a, 0x7e, 0x08, 0xd5, 0x2c, 0xa3, 0xd2, 0xb6, 0xcb, 0x23, 0x23, 0xe7, 0x8e, 0x8f, 0x4f, 0x9e, 0x12, 0xea, 0x61, 0xc6, 0xe1, 0x6c, 0xc0, 0xba, 0xb6, 0x59, 0x4a, 0x74, 0xc1, 0xc6, 0xc4, 0x0b, 0x8e, 0xa2, 0x80, 0x7c, 0xa9, 0x24, 0xbe, 0x05, 0xc2, 0xd9, 0x2e, 0xcd, 0xb8, 0xd8, 0x1a, 0x6e, 0xf2, 0xf9, 0x49, 0x86, 0x7e, 0x0a, 0x70, 0x4e, 0xe6, 0x6e, 0xca, 0xfc, 0x97, 0x0d, 0x2a, 0xc3, 0xea, 0x6e, 0x67, 0x6f, 0x7d, 0xa4, 0xd2, 0xfe, 0x31, 0x99, 0x0b, 0xcf, 0xb6, 0xcf, 0xe5, 0x28, 0x73, 0xbe, 0x80, 0x75, 0x4d, 0x81, 0x74, 0xe9, 0x3b, 0x00, 0x29, 0xf1, 0x02, 0x37, 0x64, 0x54, 0xa9, 0xa3, 0x9d, 0x2a, 0x36, 0x74, 0x13, 0x1a, 0xcc, 0x05, 0x24, 0xe0, 0x5e, 0xd2, 0x35, 0x3c, 0x89, 0xfd, 0xf3, 0xa3, 0x68, 0x1c, 0x63, 0xc9, 0xe0, 0x7c, 0x53, 0x85, 0xa6, 0xb2, 0x7b, 0x04, 0x2d, 0x7f, 0x1a, 0xb8, 0x74, 0x9e, 0x08, 0x38, 0xf4, 0xf7, 0x36, 0x46, 0x1a, 0xb6, 0xf7, 0xa7, 0xc1, 0xc9, 0x3c, 0x21, 0xb8, 0xe9, 0x8b, 0x01, 0xda, 0x85, 0xea, 0x29, 0xa1, 0x52, 0xc7, 0x15, 0x9d, 0x35, 0x47, 0x24, 0x66, 0x2c, 0x8c, 0x33, 0x99, 0x51, 0x9e, 0x51, 0x05, 0xce, 0x1c, 0x66, 0x98, 0xb1, 0xa0, 0xf7, 0xa1, 0x11, 0xf0, 0x14, 0x1b, 0xd4, 0x39, 0xf3, 0x5b, 0x3a, 0xb3, 0x01, 0x1f, 0x2c, 0x19, 0xd1, 0x8f, 0xa0, 0x96, 0x45, 0x5e, 0x32, 0x68, 0xf0, 0x0d, 0x5b, 0xfa, 0x06, 0x2d, 0x2d, 0x31, 0x67, 0x42, 0x1f, 0x42, 0x2b, 0x91, 0x59, 0x31, 0x68, 0xf2, 0x0d, 0xd7, 0x0c, 0x73, 0xcc, 0x04, 0xc4, 0x0b, 0x66, 0xf4, 0x29, 0x74, 0x85, 0x3e, 0x11, 0xbc, 0x41, 0x8b, 0x6f, 0xde, 0x2e, 0x31, 0x4f, 0x03, 0x26, 0xee, 0x04, 0x39, 0x0d, 0x7d, 0x0c, 0x10, 0xf2, 0x04, 0x62, 0xd9, 0x35, 0x68, 0x73, 0x01, 0x6f, 0xeb, 0x02, 0x8a, 0xb9, 0x89, 0xdb, 0x82, 0xff, 0x38, 0xa3, 0x6c, 0xb3, 0x16, 0x72, 0x58, 0xde, 0x5c, 0x4c, 0x43, 0x2d, 0x21, 0x9c, 0xff, 0x56, 0xa1, 0xb5, 0x48, 0x9e, 0x37, 0x0d, 0xf3, 0x4d, 0x3d, 0xcc, 0x5b, 0x4b, 0x61, 0x16, 0x52, 0x45, 0x9c, 0x6f, 0xea, 0x71, 0xde, 0x5a, 0x8a, 0xb3, 0x62, 0x65, 0x81, 0xde, 0x2b, 0x04, 0xfa, 0x6a, 0x59, 0xa0, 0xe5, 0x06, 0x15, 0xe9, 0x1f, 0x1b, 0x91, 0x1e, 0x2c, 0x47, 0x5a, 0xf2, 0x8b, 0x50, 0x7f, 0xb4, 0x14, 0xea, 0xb7, 0xcb, 0x43, 0x2d, 0x77, 0xe5, 0xb1, 0xfe, 0x04, 0x58, 0xdc, 0x0a, 0xa1, 0xde, 0x59, 0x19, 0x6a, 0xb9, 0x1f, 0xf8, 0x1e, 0x11, 0xea, 0xbb, 0x25, 0xa1, 0x7e, 0x67, 0x45, 0xa8, 0xe5, 0x76, 0x2d, 0xd6, 0x77, 0x4b, 0x62, 0xfd, 0xce, 0x8a, 0x58, 0xab, 0xdd, 0x79, 0xb0, 0x63, 0x58, 0xdf, 0x3f, 0x63, 0x56, 0x3c, 0x23, 0x24, 0x55, 0xd8, 0xfe, 0x08, 0x3a, 0x3e, 0x27, 0xea, 0x71, 0xdf, 0x1a, 0xa9, 0xfb, 0x77, 0x3f, 0x8e, 0xc6, 0x62, 0x13, 0x8f, 0x3d, 0xf8, 0x8b, 0x31, 0x1a, 0x42, 0x2d, 0x21, 0x24, 0x95, 0xf1, 0xef, 0xaa, 0xe2, 0xcd, 0x85, 0xf3, 0x15, 0xe7, 0x2e, 0x20, 0x5d, 0xe1, 0x1b, 0x96, 0xfd, 0x5f, 0xc2, 0x46, 0xbe, 0xfb, 0xf3, 0x3d, 0x65, 0xf0, 0x87, 0xd0, 0x14, 0x46, 0xb0, 0x1a, 0x5a, 0x2d, 0x3a, 0x60, 0xe9, 0x80, 0x58, 0x71, 0x3b, 0xf7, 0x60, 0xd3, 0x94, 0xf7, 0x86, 0xf6, 0x7c, 0x6d, 0x41, 0xf7, 0x38, 0x99, 0x84, 0x8b, 0xeb, 0x9f, 0x5d, 0xa6, 0x6c, 0xee, 0xe6, 0x57, 0x51, 0x8b, 0x13, 0xd8, 0x9d, 0xe9, 0x40, 0x2f, 0x22, 0x2f, 0x5d, 0xb1, 0xd7, 0x0d, 0x45, 0xc5, 0xad, 0xe1, 0x4e, 0x44, 0x5e, 0x0a, 0xb9, 0x47, 0x01, 0x1a, 0x42, 0x97, 0xf1, 0x30, 0x5f, 0xb9, 0x61, 0x90, 0x0d, 0xaa, 0xc3, 0xea, 0x6e, 0x0d, 0x43, 0x44, 0x5e, 0x32, 0x13, 0x8f, 0x82, 0x0c, 0xfd, 0x00, 0xba, 0x69, 0x78, 0x7a, 0x46, 0xdd, 0x80, 0xa4, 0xe1, 0x05, 0x11, 0x57, 0xef, 0x83, 0xca, 0xc0, 0xc2, 0x1d, 0x4e, 0x3f, 0xe0, 0x64, 0xe7, 0xb7, 0xd0, 0x93, 0x96, 0xc9, 0x33, 0x39, 0x50, 0x9b, 0x90, 0x31, 0x5d, 0x71, 0x22, 0xbe, 0x86, 0xde, 0x83, 0x3a, 0x97, 0x21, 0x03, 0x58, 0x64, 0x12, 0x8b, 0xce, 0x04, 0xd6, 0x1f, 0x78, 0xd4, 0x3f, 0x33, 0x4e, 0xfe, 0x33, 0x68, 0xa5, 0x62, 0xa8, 0x82, 0x60, 0x62, 0x4e, 0xe3, 0xc5, 0x0b, 0x4e, 0x74, 0xbd, 0x70, 0x98, 0x0a, 0xef, 0x23, 0x8c, 0x83, 0xdc, 0x03, 0xa4, 0x6b, 0x93, 0xa7, 0xd9, 0x85, 0xa6, 0xf0, 0xa3, 0xd2, 0x56, 0xb4, 0x55, 0x2d, 0x3b, 0xbf, 0x87, 0xf5, 0xfd, 0x78, 0x9a, 0x78, 0x3e, 0x7d, 0x12, 0x9f, 0x2a, 0x6b, 0xdf, 0x85, 0x9e, 0x2f, 0x88, 0xc6, 0xbd, 0xd8, 0x95, 0x44, 0x71, 0x35, 0x5e, 0x07, 0x35, 0x77, 0x29, 0x49, 0xa7, 0x2a, 0x5c, 0x92, 0x76, 0x42, 0xd2, 0xa9, 0xb3, 0x09, 0x48, 0x17, 0x2e, 0x2f, 0xfa, 0x2f, 0xe0, 0xf2, 0x49, 0xea, 0x45, 0xd9, 0x98, 0xa4, 0x4f, 0x88, 0x17, 0xe4, 0xc8, 0x52, 0xf8, 0xb0, 0x56, 0xe1, 0x03, 0x39, 0x50, 0x67, 0xbf, 0xea, 0xbe, 0x37, 0x59, 0xc4, 0x92, 0x33, 0x80, 0x2b, 0x45, 0xf1, 0x52, 0xf1, 0x48, 0x98, 0x33, 0xa3, 0xe4, 0x91, 0x97, 0x9d, 0x29, 0xad, 0x03, 0x68, 0xfa, 0x71, 0x44, 0xc9, 0x97, 0x54, 0xa6, 0xa4, 0x9a, 0x3a, 0xbf, 0x81, 0xf5, 0xcf, 0x49, 0x1a, 0x8e, 0xe7, 0x3a, 0xfb, 0x26, 0xd4, 0x75, 0x9f, 0x88, 0x09, 0x6b, 0x9b, 0xce, 0xbc, 0xec, 0x4c, 0xf6, 0x52, 0x7c, 0xac, 0x0b, 0xae, 0x9a, 0x82, 0x37, 0x01, 0xe9, 0x82, 0xa5, 0x79, 0xbf, 0x83, 0x8d, 0x67, 0x29, 0x49, 0xbc, 0x94, 0x3c, 0x25, 0x69, 0xde, 0x91, 0x5e, 0x83, 0xf6, 0x34, 0x8c, 0x8c, 0x40, 0xb4, 0xa6, 0x61, 0x24, 0x82, 0x70, 0x03, 0x1a, 0xd4, 0x4b, 0xf3, 0x4b, 0x65, 0x09, 0x8a, 0x62, 0xd5, 0xb9, 0x02, 0x9b, 0xa6, 0x6c, 0xa9, 0xf3, 0x0f, 0xdc, 0x25, 0xd3, 0x90, 0x1a, 0x2a, 0x6f, 0x40, 0x23, 0x8b, 0x67, 0xa9, 0x4f, 0x56, 0x01, 0x5c, 0xac, 0xa2, 0x2b, 0xd0, 0xf0, 0xf9, 0x6e, 0x19, 0x7c, 0x39, 0x63, 0xe9, 0x47, 0x22, 0x9a, 0x86, 0x44, 0x20, 0x94, 0x09, 0x50, 0xe5, 0xf1, 0x30, 0xa2, 0xe9, 0x1c, 0xab, 0x65, 0xd6, 0x07, 0x1b, 0xfa, 0x17, 0x91, 0xda, 0xc4, 0xf1, 0x64, 0xf2, 0xdc, 0xf3, 0xcf, 0x0d, 0xc3, 0x72, 0x85, 0x96, 0xae, 0xd0, 0xd9, 0x82, 0xcb, 0x05, 0x7e, 0x29, 0xe8, 0x4f, 0x0d, 0xe8, 0x7e, 0x1a, 0x4c, 0xc3, 0x48, 0x49, 0xb8, 0xbd, 0x74, 0x65, 0x1b, 0x40, 0xe4, 0xbc, 0x4b, 0xf7, 0xf6, 0xbd, 0x45, 0xc9, 0xd7, 0xea, 0xf7, 0xb7, 0x54, 0x51, 0x59, 0xf8, 0x19, 0x09, 0xed, 0x41, 0x9d, 0x97, 0x39, 0x9e, 0x07, 0xaf, 0x81, 0x3e, 0xaf, 0x53, 0x82, 0x95, 0xeb, 0x94, 0xf0, 0x9a, 0xc4, 0xa7, 0xb2, 0x11, 0x30, 0x75, 0x16, 0x71, 0x8b, 0xc1, 0x5f, 0x90, 0xd0, 0x2f, 0x60, 0x8d, 0x4a, 0x18, 0xb8, 0x13, 0x8e, 0x03, 0xd9, 0x1e, 0x5c, 0xd7, 0x65, 0x94, 0x02, 0x11, 0xf7, 0xa9, 0x41, 0x66, 0xb6, 0x5c, 0xf0, 0x7c, 0x75, 0x79, 0x92, 0x37, 0x96, 0x6d, 0x59, 0xc2, 0x09, 0x86, 0x8b, 0x05, 0x09, 0x1d, 0x40, 0x2f, 0x11, 0xd9, 0xe7, 0x4e, 0x59, 0x78, 0x64, 0x13, 0xb1, 0x53, 0x68, 0x22, 0x8a, 0xa9, 0x8f, 0xbb, 0x89, 0x46, 0x64, 0x7d, 0xa3, 0x08, 0xb7, 0x14, 0x52, 0xd2, 0x37, 0x2e, 0xe7, 0x32, 0x2f, 0x48, 0x8a, 0x86, 0x1e, 0x42, 0x3f, 0x95, 0x79, 0x22, 0x85, 0x88, 0x86, 0x62, 0x68, 0xb4, 0x04, 0x25, 0x99, 0x87, 0x7b, 0xa9, 0x4e, 0x45, 0x1f, 0x40, 0x83, 0x87, 0x29, 0x2b, 0xeb, 0x29, 0x96, 0xca, 0x3f, 0x96, 0xcc, 0xe8, 0x10, 0xfa, 0x5a, 0x22, 0xb9, 0x17, 0x7b, 0x83, 0xce, 0xb2, 0x27, 0x4a, 0xee, 0x70, 0xdc, 0xf5, 0x35, 0xa2, 0xf4, 0x04, 0x2b, 0x64, 0x22, 0x20, 0xdd, 0x52, 0x4f, 0x14, 0x0a, 0x9d, 0x28, 0xcd, 0x92, 0xe6, 0xfc, 0xab, 0x0e, 0x3d, 0x09, 0x0c, 0x79, 0x67, 0x7c, 0x2f, 0x64, 0xdc, 0x2f, 0x43, 0xc6, 0xf6, 0x2a, 0x64, 0xa8, 0xf6, 0x4e, 0x83, 0xc6, 0x6d, 0x13, 0x1a, 0x6f, 0x95, 0x40, 0x43, 0xec, 0xd2, 0xb1, 0x71, 0xbf, 0x0c, 0x1b, 0xdb, 0xab, 0xb0, 0xb1, 0xd0, 0x9a, 0x83, 0xe3, 0xf1, 0x2a, 0x70, 0x38, 0xaf, 0x03, 0x87, 0x14, 0x54, 0x44, 0xc7, 0xfd, 0x32, 0x74, 0x6c, 0xaf, 0x42, 0x87, 0xb2, 0x46, 0x83, 0xc7, 0x61, 0x39, 0x3c, 0x86, 0xab, 0xe1, 0x21, 0x85, 0x98, 0xf8, 0x78, 0x50, 0x8a, 0x8f, 0x9d, 0x95, 0xf8, 0x90, 0x42, 0x0c, 0x80, 0x3c, 0x5a, 0x01, 0x90, 0xeb, 0xaf, 0x01, 0x88, 0x94, 0x53, 0x40, 0xc8, 0x9d, 0x02, 0x42, 0xb6, 0x57, 0x21, 0x44, 0xbd, 0x4c, 0x24, 0x44, 0x3e, 0x5b, 0x01, 0x91, 0xe1, 0x6a, 0x88, 0x28, 0x6f, 0xe8, 0x18, 0x61, 0x37, 0x8b, 0xb8, 0xad, 0x8c, 0xd2, 0xe6, 0xdc, 0x85, 0x4d, 0x93, 0x2c, 0xb3, 0xff, 0x3d, 0x68, 0xc8, 0x44, 0x28, 0xeb, 0x3e, 0xe4, 0x5a, 0x2e, 0xf4, 0x80, 0x50, 0x2f, 0x9c, 0x28, 0xa1, 0x81, 0x12, 0xaa, 0xc8, 0x6f, 0xd6, 0x28, 0x6b, 0xca, 0x2b, 0xaf, 0x51, 0xfe, 0x37, 0x0b, 0x7a, 0xc7, 0xd4, 0xa3, 0xb3, 0x4c, 0xeb, 0x2a, 0x0b, 0x90, 0x35, 0xf1, 0xc3, 0x99, 0x97, 0x30, 0x7b, 0x00, 0x3d, 0xd9, 0x64, 0x1b, 0x4a, 0x77, 0xcc, 0x67, 0xd1, 0x92, 0xeb, 0x70, 0x37, 0xd5, 0x88, 0x9a, 0x94, 0x80, 0x1f, 0x5a, 0x02, 0xb8, 0x44, 0x8a, 0xe1, 0x2b, 0x25, 0x45, 0x10, 0x9d, 0xbf, 0x5b, 0xd0, 0x57, 0x67, 0x92, 0x4e, 0xfb, 0x7e, 0x87, 0x3a, 0x2c, 0x3f, 0xd4, 0x70, 0xf5, 0xa1, 0x54, 0xd6, 0x18, 0xa7, 0x3a, 0x2c, 0x3f, 0xd5, 0x70, 0xf5, 0xa9, 0x4c, 0x31, 0xf2, 0x58, 0xff, 0xa9, 0xc0, 0x3a, 0xf6, 0xc6, 0xaa, 0xfe, 0x3f, 0x12, 0xc2, 0xaf, 0x41, 0x3b, 0x7f, 0xdd, 0xc8, 0x4e, 0x2e, 0xcd, 0x9f, 0x36, 0xdf, 0xf2, 0x38, 0x44, 0x3b, 0xd0, 0xe1, 0x6f, 0xd9, 0x17, 0xb3, 0x38, 0x9d, 0x4d, 0xb9, 0x65, 0x2d, 0xcc, 0x9f, 0xb7, 0xbf, 0xe6, 0x14, 0xd6, 0x84, 0xce, 0x66, 0x61, 0xc0, 0xeb, 0x61, 0x17, 0xf3, 0x31, 0xba, 0x03, 0xd2, 0x32, 0x97, 0x24, 0xb1, 0x7f, 0x26, 0xcb, 0xdc, 0x86, 0x99, 0x88, 0x87, 0x6c, 0x09, 0x77, 0xd2, 0x7c, 0xc2, 0x64, 0xf1, 0xae, 0xbe, 0xc1, 0xcd, 0xe4, 0x63, 0xfe, 0x35, 0x6e, 0x1e, 0xf9, 0xbc, 0xe6, 0x36, 0xb9, 0xf6, 0x26, 0x9b, 0xb3, 0x82, 0xca, 0x5e, 0x2a, 0x24, 0x99, 0x84, 0xbe, 0xe7, 0x32, 0x83, 0x78, 0xed, 0x61, 0x2f, 0x15, 0x41, 0x63, 0x8f, 0x6c, 0xf6, 0xa8, 0xf0, 0x92, 0x64, 0x12, 0x12, 0xf5, 0x1a, 0x6f, 0x8b, 0x47, 0x85, 0x24, 0x8a, 0x7e, 0x76, 0x13, 0xea, 0xe3, 0x89, 0x77, 0x2a, 0x8a, 0x46, 0x0d, 0x8b, 0x09, 0x73, 0x1c, 0x1b, 0xb8, 0x81, 0x47, 0x3d, 0x5e, 0x0e, 0xba, 0xb8, 0xc5, 0x08, 0x07, 0x1e, 0xf5, 0x9c, 0x17, 0x80, 0x84, 0xab, 0x45, 0x24, 0xa4, 0xaf, 0xdf, 0x83, 0x3a, 0xff, 0x40, 0xbe, 0x40, 0x9e, 0xfa, 0x5c, 0x7e, 0xc8, 0x7e, 0xb1, 0x58, 0x5c, 0x78, 0xac, 0xa2, 0x79, 0x8c, 0xbd, 0x6b, 0x66, 0x69, 0x4a, 0x22, 0xf9, 0xae, 0xa9, 0xca, 0x77, 0x8d, 0xa0, 0xf1, 0x77, 0xcd, 0xff, 0x2c, 0xe8, 0x33, 0x9d, 0xfb, 0xd3, 0x40, 0x41, 0xf1, 0x03, 0x68, 0x9c, 0xe9, 0xf5, 0xc3, 0xfc, 0xc8, 0x50, 0x4c, 0x05, 0x2c, 0x99, 0xd1, 0x4f, 0xb4, 0x77, 0xa1, 0x78, 0xd3, 0x6c, 0x98, 0xa9, 0x56, 0x7c, 0x12, 0xfe, 0x1c, 0x7a, 0x1e, 0xbb, 0x89, 0x5d, 0x49, 0x29, 0x6b, 0x29, 0xf5, 0x86, 0x17, 0x77, 0x3d, 0xbd, 0xfd, 0xfd, 0x04, 0xfa, 0x19, 0x07, 0xd0, 0x62, 0x7f, 0xad, 0xe4, 0xde, 0xd5, 0x8b, 0x0c, 0xee, 0x65, 0xfa, 0xd4, 0xf9, 0x63, 0x05, 0xd6, 0x16, 0x67, 0x97, 0x90, 0xbd, 0x53, 0x38, 0xfc, 0xf6, 0xf2, 0xe1, 0xf5, 0xe0, 0x2c, 0x4e, 0xbf, 0xc7, 0x00, 0x21, 0x56, 0xd4, 0xf1, 0x37, 0xcd, 0xe3, 0xe7, 0xdf, 0x64, 0x24, 0x1b, 0x3b, 0x81, 0x72, 0x80, 0x20, 0x95, 0x75, 0x0e, 0x46, 0x67, 0x83, 0x7b, 0x9e, 0xd1, 0xe8, 0xec, 0xc3, 0xda, 0xc2, 0x07, 0x52, 0x44, 0x6d, 0xf9, 0xc3, 0x99, 0x59, 0x95, 0x70, 0x3f, 0x33, 0xe6, 0xb7, 0xbe, 0x82, 0xa6, 0xac, 0x41, 0xa8, 0x03, 0xcd, 0xa3, 0xe8, 0xc2, 0x9b, 0x84, 0x81, 0x7d, 0x09, 0x35, 0xa1, 0xfa, 0x90, 0x50, 0xdb, 0x62, 0x83, 0x67, 0x33, 0x6a, 0x57, 0x11, 0x40, 0x43, 0x7c, 0xe3, 0xb2, 0x6b, 0xa8, 0x05, 0xb5, 0xe3, 0xc8, 0x4b, 0xec, 0x3a, 0xea, 0x42, 0x4b, 0x7d, 0x36, 0xb3, 0x1b, 0x68, 0x0d, 0x3a, 0xda, 0x77, 0x30, 0xbb, 0x89, 0x7a, 0xd0, 0x5e, 0x7c, 0xd7, 0xb2, 0x5b, 0x6c, 0xba, 0xf8, 0x50, 0x65, 0xb7, 0x6f, 0xfd, 0xd3, 0x92, 0xaf, 0x1a, 0x65, 0x82, 0x0d, 0x5d, 0x69, 0x02, 0x27, 0xdb, 0x97, 0x50, 0x1f, 0x20, 0xbf, 0x24, 0x6d, 0x0b, 0xf5, 0xa0, 0xce, 0xef, 0x5b, 0xbb, 0x72, 0xb5, 0xd2, 0xb2, 0xf8, 0xf2, 0xa2, 0x1d, 0xb2, 0xab, 0x08, 0x41, 0xdf, 0xec, 0x76, 0xec, 0x1a, 0x33, 0x4a, 0xeb, 0x22, 0xed, 0x3a, 0xdb, 0x94, 0x77, 0x32, 0x76, 0x83, 0x69, 0xd5, 0xdb, 0x12, 0xbb, 0x29, 0xb7, 0xa8, 0x6e, 0xc2, 0x6e, 0xa1, 0x75, 0xe8, 0x19, 0xdd, 0x82, 0xdd, 0x66, 0x52, 0xf2, 0xeb, 0xdf, 0x06, 0x26, 0x45, 0xbf, 0xce, 0xed, 0xce, 0xad, 0xcf, 0xd4, 0x3d, 0xa7, 0x8e, 0xb7, 0x0e, 0x3d, 0x79, 0x3c, 0x41, 0xb7, 0x2f, 0xb1, 0x5d, 0x7a, 0x39, 0xb7, 0xad, 0x9c, 0x22, 0x6a, 0xb0, 0x5d, 0x79, 0x70, 0xe3, 0x1f, 0x7f, 0x6e, 0x59, 0x7f, 0x79, 0xb5, 0x6d, 0xfd, 0xf5, 0xd5, 0xb6, 0xf5, 0xef, 0x57, 0xdb, 0xd6, 0xd7, 0xdf, 0x6c, 0x5f, 0x02, 0x3b, 0x4e, 0x4f, 0x47, 0x34, 0x3c, 0xbf, 0x18, 0x9d, 0x5f, 0xf0, 0x3f, 0xbe, 0x9e, 0x37, 0xf8, 0xcf, 0xed, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x9c, 0x26, 0x20, 0x7f, 0x1b, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/raft_serverpb/000077500000000000000000000000001421456440000177325ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/raft_serverpb/raft_serverpb.pb.go000066400000000000000000003073361421456440000235410ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: raft_serverpb.proto package raft_serverpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" disk_usage "github.com/pingcap/kvproto/pkg/disk_usage" eraftpb "github.com/pingcap/kvproto/pkg/eraftpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" metapb "github.com/pingcap/kvproto/pkg/metapb" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type PeerState int32 const ( PeerState_Normal PeerState = 0 PeerState_Applying PeerState = 1 PeerState_Tombstone PeerState = 2 PeerState_Merging PeerState = 3 ) var PeerState_name = map[int32]string{ 0: "Normal", 1: "Applying", 2: "Tombstone", 3: "Merging", } var PeerState_value = map[string]int32{ "Normal": 0, "Applying": 1, "Tombstone": 2, "Merging": 3, } func (x PeerState) String() string { return proto.EnumName(PeerState_name, int32(x)) } func (PeerState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{0} } type ExtraMessageType int32 const ( ExtraMessageType_MsgRegionWakeUp ExtraMessageType = 0 ExtraMessageType_MsgWantRollbackMerge ExtraMessageType = 1 ExtraMessageType_MsgCheckStalePeer ExtraMessageType = 2 ExtraMessageType_MsgCheckStalePeerResponse ExtraMessageType = 3 // If leader is going to sleep, it will send requests to all its followers // to make sure they all agree to sleep. ExtraMessageType_MsgHibernateRequest ExtraMessageType = 4 ExtraMessageType_MsgHibernateResponse ExtraMessageType = 5 ) var ExtraMessageType_name = map[int32]string{ 0: "MsgRegionWakeUp", 1: "MsgWantRollbackMerge", 2: "MsgCheckStalePeer", 3: "MsgCheckStalePeerResponse", 4: "MsgHibernateRequest", 5: "MsgHibernateResponse", } var ExtraMessageType_value = map[string]int32{ "MsgRegionWakeUp": 0, "MsgWantRollbackMerge": 1, "MsgCheckStalePeer": 2, "MsgCheckStalePeerResponse": 3, "MsgHibernateRequest": 4, "MsgHibernateResponse": 5, } func (x ExtraMessageType) String() string { return proto.EnumName(ExtraMessageType_name, int32(x)) } func (ExtraMessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{1} } type RaftMessage struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` FromPeer *metapb.Peer `protobuf:"bytes,2,opt,name=from_peer,json=fromPeer" json:"from_peer,omitempty"` ToPeer *metapb.Peer `protobuf:"bytes,3,opt,name=to_peer,json=toPeer" json:"to_peer,omitempty"` Message *eraftpb.Message `protobuf:"bytes,4,opt,name=message" json:"message,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,5,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` // true means to_peer is a tombstone peer and it should remove itself. IsTombstone bool `protobuf:"varint,6,opt,name=is_tombstone,json=isTombstone,proto3" json:"is_tombstone,omitempty"` // Region key range [start_key, end_key). StartKey []byte `protobuf:"bytes,7,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,8,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // If it has value, to_peer should be removed if merge is never going to complete. MergeTarget *metapb.Region `protobuf:"bytes,9,opt,name=merge_target,json=mergeTarget" json:"merge_target,omitempty"` ExtraMsg *ExtraMessage `protobuf:"bytes,10,opt,name=extra_msg,json=extraMsg" json:"extra_msg,omitempty"` ExtraCtx []byte `protobuf:"bytes,11,opt,name=extra_ctx,json=extraCtx,proto3" json:"extra_ctx,omitempty"` DiskUsage disk_usage.DiskUsage `protobuf:"varint,12,opt,name=disk_usage,json=diskUsage,proto3,enum=disk_usage.DiskUsage" json:"disk_usage,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftMessage) Reset() { *m = RaftMessage{} } func (m *RaftMessage) String() string { return proto.CompactTextString(m) } func (*RaftMessage) ProtoMessage() {} func (*RaftMessage) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{0} } func (m *RaftMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftMessage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftMessage.Merge(dst, src) } func (m *RaftMessage) XXX_Size() int { return m.Size() } func (m *RaftMessage) XXX_DiscardUnknown() { xxx_messageInfo_RaftMessage.DiscardUnknown(m) } var xxx_messageInfo_RaftMessage proto.InternalMessageInfo func (m *RaftMessage) GetRegionId() uint64 { if m != nil { return m.RegionId } return 0 } func (m *RaftMessage) GetFromPeer() *metapb.Peer { if m != nil { return m.FromPeer } return nil } func (m *RaftMessage) GetToPeer() *metapb.Peer { if m != nil { return m.ToPeer } return nil } func (m *RaftMessage) GetMessage() *eraftpb.Message { if m != nil { return m.Message } return nil } func (m *RaftMessage) GetRegionEpoch() *metapb.RegionEpoch { if m != nil { return m.RegionEpoch } return nil } func (m *RaftMessage) GetIsTombstone() bool { if m != nil { return m.IsTombstone } return false } func (m *RaftMessage) GetStartKey() []byte { if m != nil { return m.StartKey } return nil } func (m *RaftMessage) GetEndKey() []byte { if m != nil { return m.EndKey } return nil } func (m *RaftMessage) GetMergeTarget() *metapb.Region { if m != nil { return m.MergeTarget } return nil } func (m *RaftMessage) GetExtraMsg() *ExtraMessage { if m != nil { return m.ExtraMsg } return nil } func (m *RaftMessage) GetExtraCtx() []byte { if m != nil { return m.ExtraCtx } return nil } func (m *RaftMessage) GetDiskUsage() disk_usage.DiskUsage { if m != nil { return m.DiskUsage } return disk_usage.DiskUsage_Normal } type RaftTruncatedState struct { Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` Term uint64 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftTruncatedState) Reset() { *m = RaftTruncatedState{} } func (m *RaftTruncatedState) String() string { return proto.CompactTextString(m) } func (*RaftTruncatedState) ProtoMessage() {} func (*RaftTruncatedState) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{1} } func (m *RaftTruncatedState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftTruncatedState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftTruncatedState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftTruncatedState) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftTruncatedState.Merge(dst, src) } func (m *RaftTruncatedState) XXX_Size() int { return m.Size() } func (m *RaftTruncatedState) XXX_DiscardUnknown() { xxx_messageInfo_RaftTruncatedState.DiscardUnknown(m) } var xxx_messageInfo_RaftTruncatedState proto.InternalMessageInfo func (m *RaftTruncatedState) GetIndex() uint64 { if m != nil { return m.Index } return 0 } func (m *RaftTruncatedState) GetTerm() uint64 { if m != nil { return m.Term } return 0 } type SnapshotCFFile struct { Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` Size_ uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` Checksum uint32 `protobuf:"varint,3,opt,name=checksum,proto3" json:"checksum,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotCFFile) Reset() { *m = SnapshotCFFile{} } func (m *SnapshotCFFile) String() string { return proto.CompactTextString(m) } func (*SnapshotCFFile) ProtoMessage() {} func (*SnapshotCFFile) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{2} } func (m *SnapshotCFFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotCFFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotCFFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotCFFile) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotCFFile.Merge(dst, src) } func (m *SnapshotCFFile) XXX_Size() int { return m.Size() } func (m *SnapshotCFFile) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotCFFile.DiscardUnknown(m) } var xxx_messageInfo_SnapshotCFFile proto.InternalMessageInfo func (m *SnapshotCFFile) GetCf() string { if m != nil { return m.Cf } return "" } func (m *SnapshotCFFile) GetSize_() uint64 { if m != nil { return m.Size_ } return 0 } func (m *SnapshotCFFile) GetChecksum() uint32 { if m != nil { return m.Checksum } return 0 } type SnapshotMeta struct { CfFiles []*SnapshotCFFile `protobuf:"bytes,1,rep,name=cf_files,json=cfFiles" json:"cf_files,omitempty"` // true means this snapshot is triggered for load balance ForBalance bool `protobuf:"varint,2,opt,name=for_balance,json=forBalance,proto3" json:"for_balance,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SnapshotMeta) Reset() { *m = SnapshotMeta{} } func (m *SnapshotMeta) String() string { return proto.CompactTextString(m) } func (*SnapshotMeta) ProtoMessage() {} func (*SnapshotMeta) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{3} } func (m *SnapshotMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotMeta.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotMeta) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotMeta.Merge(dst, src) } func (m *SnapshotMeta) XXX_Size() int { return m.Size() } func (m *SnapshotMeta) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotMeta.DiscardUnknown(m) } var xxx_messageInfo_SnapshotMeta proto.InternalMessageInfo func (m *SnapshotMeta) GetCfFiles() []*SnapshotCFFile { if m != nil { return m.CfFiles } return nil } func (m *SnapshotMeta) GetForBalance() bool { if m != nil { return m.ForBalance } return false } type SnapshotChunk struct { Message *RaftMessage `protobuf:"bytes,1,opt,name=message" json:"message,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 *SnapshotChunk) Reset() { *m = SnapshotChunk{} } func (m *SnapshotChunk) String() string { return proto.CompactTextString(m) } func (*SnapshotChunk) ProtoMessage() {} func (*SnapshotChunk) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{4} } func (m *SnapshotChunk) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SnapshotChunk.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SnapshotChunk) XXX_Merge(src proto.Message) { xxx_messageInfo_SnapshotChunk.Merge(dst, src) } func (m *SnapshotChunk) XXX_Size() int { return m.Size() } func (m *SnapshotChunk) XXX_DiscardUnknown() { xxx_messageInfo_SnapshotChunk.DiscardUnknown(m) } var xxx_messageInfo_SnapshotChunk proto.InternalMessageInfo func (m *SnapshotChunk) GetMessage() *RaftMessage { if m != nil { return m.Message } return nil } func (m *SnapshotChunk) GetData() []byte { if m != nil { return m.Data } return nil } type Done struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Done) Reset() { *m = Done{} } func (m *Done) String() string { return proto.CompactTextString(m) } func (*Done) ProtoMessage() {} func (*Done) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{5} } func (m *Done) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Done) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Done.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Done) XXX_Merge(src proto.Message) { xxx_messageInfo_Done.Merge(dst, src) } func (m *Done) XXX_Size() int { return m.Size() } func (m *Done) XXX_DiscardUnknown() { xxx_messageInfo_Done.DiscardUnknown(m) } var xxx_messageInfo_Done proto.InternalMessageInfo type KeyValue struct { Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyValue) Reset() { *m = KeyValue{} } func (m *KeyValue) String() string { return proto.CompactTextString(m) } func (*KeyValue) ProtoMessage() {} func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{6} } func (m *KeyValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *KeyValue) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyValue.Merge(dst, src) } func (m *KeyValue) XXX_Size() int { return m.Size() } func (m *KeyValue) XXX_DiscardUnknown() { xxx_messageInfo_KeyValue.DiscardUnknown(m) } var xxx_messageInfo_KeyValue proto.InternalMessageInfo func (m *KeyValue) GetKey() []byte { if m != nil { return m.Key } return nil } func (m *KeyValue) GetValue() []byte { if m != nil { return m.Value } return nil } type RaftSnapshotData struct { Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` FileSize uint64 `protobuf:"varint,2,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty"` Data []*KeyValue `protobuf:"bytes,3,rep,name=data" json:"data,omitempty"` Version uint64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` Meta *SnapshotMeta `protobuf:"bytes,5,opt,name=meta" json:"meta,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftSnapshotData) Reset() { *m = RaftSnapshotData{} } func (m *RaftSnapshotData) String() string { return proto.CompactTextString(m) } func (*RaftSnapshotData) ProtoMessage() {} func (*RaftSnapshotData) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{7} } func (m *RaftSnapshotData) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftSnapshotData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftSnapshotData.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftSnapshotData) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftSnapshotData.Merge(dst, src) } func (m *RaftSnapshotData) XXX_Size() int { return m.Size() } func (m *RaftSnapshotData) XXX_DiscardUnknown() { xxx_messageInfo_RaftSnapshotData.DiscardUnknown(m) } var xxx_messageInfo_RaftSnapshotData proto.InternalMessageInfo func (m *RaftSnapshotData) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *RaftSnapshotData) GetFileSize() uint64 { if m != nil { return m.FileSize } return 0 } func (m *RaftSnapshotData) GetData() []*KeyValue { if m != nil { return m.Data } return nil } func (m *RaftSnapshotData) GetVersion() uint64 { if m != nil { return m.Version } return 0 } func (m *RaftSnapshotData) GetMeta() *SnapshotMeta { if m != nil { return m.Meta } return nil } type StoreIdent struct { ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` ApiVersion kvrpcpb.APIVersion `protobuf:"varint,3,opt,name=api_version,json=apiVersion,proto3,enum=kvrpcpb.APIVersion" json:"api_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreIdent) Reset() { *m = StoreIdent{} } func (m *StoreIdent) String() string { return proto.CompactTextString(m) } func (*StoreIdent) ProtoMessage() {} func (*StoreIdent) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{8} } func (m *StoreIdent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreIdent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreIdent.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreIdent) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreIdent.Merge(dst, src) } func (m *StoreIdent) XXX_Size() int { return m.Size() } func (m *StoreIdent) XXX_DiscardUnknown() { xxx_messageInfo_StoreIdent.DiscardUnknown(m) } var xxx_messageInfo_StoreIdent proto.InternalMessageInfo func (m *StoreIdent) GetClusterId() uint64 { if m != nil { return m.ClusterId } return 0 } func (m *StoreIdent) GetStoreId() uint64 { if m != nil { return m.StoreId } return 0 } func (m *StoreIdent) GetApiVersion() kvrpcpb.APIVersion { if m != nil { return m.ApiVersion } return kvrpcpb.APIVersion_V1 } type RaftLocalState struct { HardState *eraftpb.HardState `protobuf:"bytes,1,opt,name=hard_state,json=hardState" json:"hard_state,omitempty"` LastIndex uint64 `protobuf:"varint,2,opt,name=last_index,json=lastIndex,proto3" json:"last_index,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftLocalState) Reset() { *m = RaftLocalState{} } func (m *RaftLocalState) String() string { return proto.CompactTextString(m) } func (*RaftLocalState) ProtoMessage() {} func (*RaftLocalState) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{9} } func (m *RaftLocalState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftLocalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftLocalState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftLocalState) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftLocalState.Merge(dst, src) } func (m *RaftLocalState) XXX_Size() int { return m.Size() } func (m *RaftLocalState) XXX_DiscardUnknown() { xxx_messageInfo_RaftLocalState.DiscardUnknown(m) } var xxx_messageInfo_RaftLocalState proto.InternalMessageInfo func (m *RaftLocalState) GetHardState() *eraftpb.HardState { if m != nil { return m.HardState } return nil } func (m *RaftLocalState) GetLastIndex() uint64 { if m != nil { return m.LastIndex } return 0 } type RaftApplyState struct { AppliedIndex uint64 `protobuf:"varint,1,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` LastCommitIndex uint64 `protobuf:"varint,3,opt,name=last_commit_index,json=lastCommitIndex,proto3" json:"last_commit_index,omitempty"` CommitIndex uint64 `protobuf:"varint,4,opt,name=commit_index,json=commitIndex,proto3" json:"commit_index,omitempty"` CommitTerm uint64 `protobuf:"varint,5,opt,name=commit_term,json=commitTerm,proto3" json:"commit_term,omitempty"` TruncatedState *RaftTruncatedState `protobuf:"bytes,2,opt,name=truncated_state,json=truncatedState" json:"truncated_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RaftApplyState) Reset() { *m = RaftApplyState{} } func (m *RaftApplyState) String() string { return proto.CompactTextString(m) } func (*RaftApplyState) ProtoMessage() {} func (*RaftApplyState) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{10} } func (m *RaftApplyState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RaftApplyState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RaftApplyState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RaftApplyState) XXX_Merge(src proto.Message) { xxx_messageInfo_RaftApplyState.Merge(dst, src) } func (m *RaftApplyState) XXX_Size() int { return m.Size() } func (m *RaftApplyState) XXX_DiscardUnknown() { xxx_messageInfo_RaftApplyState.DiscardUnknown(m) } var xxx_messageInfo_RaftApplyState proto.InternalMessageInfo func (m *RaftApplyState) GetAppliedIndex() uint64 { if m != nil { return m.AppliedIndex } return 0 } func (m *RaftApplyState) GetLastCommitIndex() uint64 { if m != nil { return m.LastCommitIndex } return 0 } func (m *RaftApplyState) GetCommitIndex() uint64 { if m != nil { return m.CommitIndex } return 0 } func (m *RaftApplyState) GetCommitTerm() uint64 { if m != nil { return m.CommitTerm } return 0 } func (m *RaftApplyState) GetTruncatedState() *RaftTruncatedState { if m != nil { return m.TruncatedState } return nil } type MergeState struct { MinIndex uint64 `protobuf:"varint,1,opt,name=min_index,json=minIndex,proto3" json:"min_index,omitempty"` Target *metapb.Region `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MergeState) Reset() { *m = MergeState{} } func (m *MergeState) String() string { return proto.CompactTextString(m) } func (*MergeState) ProtoMessage() {} func (*MergeState) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{11} } func (m *MergeState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MergeState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MergeState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *MergeState) XXX_Merge(src proto.Message) { xxx_messageInfo_MergeState.Merge(dst, src) } func (m *MergeState) XXX_Size() int { return m.Size() } func (m *MergeState) XXX_DiscardUnknown() { xxx_messageInfo_MergeState.DiscardUnknown(m) } var xxx_messageInfo_MergeState proto.InternalMessageInfo func (m *MergeState) GetMinIndex() uint64 { if m != nil { return m.MinIndex } return 0 } func (m *MergeState) GetTarget() *metapb.Region { if m != nil { return m.Target } return nil } func (m *MergeState) GetCommit() uint64 { if m != nil { return m.Commit } return 0 } type RegionLocalState struct { State PeerState `protobuf:"varint,1,opt,name=state,proto3,enum=raft_serverpb.PeerState" json:"state,omitempty"` Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` MergeState *MergeState `protobuf:"bytes,3,opt,name=merge_state,json=mergeState" json:"merge_state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionLocalState) Reset() { *m = RegionLocalState{} } func (m *RegionLocalState) String() string { return proto.CompactTextString(m) } func (*RegionLocalState) ProtoMessage() {} func (*RegionLocalState) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{12} } func (m *RegionLocalState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionLocalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionLocalState.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionLocalState) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionLocalState.Merge(dst, src) } func (m *RegionLocalState) XXX_Size() int { return m.Size() } func (m *RegionLocalState) XXX_DiscardUnknown() { xxx_messageInfo_RegionLocalState.DiscardUnknown(m) } var xxx_messageInfo_RegionLocalState proto.InternalMessageInfo func (m *RegionLocalState) GetState() PeerState { if m != nil { return m.State } return PeerState_Normal } func (m *RegionLocalState) GetRegion() *metapb.Region { if m != nil { return m.Region } return nil } func (m *RegionLocalState) GetMergeState() *MergeState { if m != nil { return m.MergeState } return nil } type ExtraMessage struct { Type ExtraMessageType `protobuf:"varint,1,opt,name=type,proto3,enum=raft_serverpb.ExtraMessageType" json:"type,omitempty"` PremergeCommit uint64 `protobuf:"varint,2,opt,name=premerge_commit,json=premergeCommit,proto3" json:"premerge_commit,omitempty"` CheckPeers []*metapb.Peer `protobuf:"bytes,3,rep,name=check_peers,json=checkPeers" json:"check_peers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExtraMessage) Reset() { *m = ExtraMessage{} } func (m *ExtraMessage) String() string { return proto.CompactTextString(m) } func (*ExtraMessage) ProtoMessage() {} func (*ExtraMessage) Descriptor() ([]byte, []int) { return fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d, []int{13} } func (m *ExtraMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExtraMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExtraMessage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ExtraMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_ExtraMessage.Merge(dst, src) } func (m *ExtraMessage) XXX_Size() int { return m.Size() } func (m *ExtraMessage) XXX_DiscardUnknown() { xxx_messageInfo_ExtraMessage.DiscardUnknown(m) } var xxx_messageInfo_ExtraMessage proto.InternalMessageInfo func (m *ExtraMessage) GetType() ExtraMessageType { if m != nil { return m.Type } return ExtraMessageType_MsgRegionWakeUp } func (m *ExtraMessage) GetPremergeCommit() uint64 { if m != nil { return m.PremergeCommit } return 0 } func (m *ExtraMessage) GetCheckPeers() []*metapb.Peer { if m != nil { return m.CheckPeers } return nil } func init() { proto.RegisterType((*RaftMessage)(nil), "raft_serverpb.RaftMessage") proto.RegisterType((*RaftTruncatedState)(nil), "raft_serverpb.RaftTruncatedState") proto.RegisterType((*SnapshotCFFile)(nil), "raft_serverpb.SnapshotCFFile") proto.RegisterType((*SnapshotMeta)(nil), "raft_serverpb.SnapshotMeta") proto.RegisterType((*SnapshotChunk)(nil), "raft_serverpb.SnapshotChunk") proto.RegisterType((*Done)(nil), "raft_serverpb.Done") proto.RegisterType((*KeyValue)(nil), "raft_serverpb.KeyValue") proto.RegisterType((*RaftSnapshotData)(nil), "raft_serverpb.RaftSnapshotData") proto.RegisterType((*StoreIdent)(nil), "raft_serverpb.StoreIdent") proto.RegisterType((*RaftLocalState)(nil), "raft_serverpb.RaftLocalState") proto.RegisterType((*RaftApplyState)(nil), "raft_serverpb.RaftApplyState") proto.RegisterType((*MergeState)(nil), "raft_serverpb.MergeState") proto.RegisterType((*RegionLocalState)(nil), "raft_serverpb.RegionLocalState") proto.RegisterType((*ExtraMessage)(nil), "raft_serverpb.ExtraMessage") proto.RegisterEnum("raft_serverpb.PeerState", PeerState_name, PeerState_value) proto.RegisterEnum("raft_serverpb.ExtraMessageType", ExtraMessageType_name, ExtraMessageType_value) } func (m *RaftMessage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftMessage) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RegionId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.RegionId)) } if m.FromPeer != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.FromPeer.Size())) n1, err := m.FromPeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.ToPeer != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.ToPeer.Size())) n2, err := m.ToPeer.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } if m.Message != nil { dAtA[i] = 0x22 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Message.Size())) n3, err := m.Message.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } if m.RegionEpoch != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.RegionEpoch.Size())) n4, err := m.RegionEpoch.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } if m.IsTombstone { dAtA[i] = 0x30 i++ if m.IsTombstone { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if len(m.StartKey) > 0 { dAtA[i] = 0x3a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.StartKey))) i += copy(dAtA[i:], m.StartKey) } if len(m.EndKey) > 0 { dAtA[i] = 0x42 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } if m.MergeTarget != nil { dAtA[i] = 0x4a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MergeTarget.Size())) n5, err := m.MergeTarget.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.ExtraMsg != nil { dAtA[i] = 0x52 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.ExtraMsg.Size())) n6, err := m.ExtraMsg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } if len(m.ExtraCtx) > 0 { dAtA[i] = 0x5a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.ExtraCtx))) i += copy(dAtA[i:], m.ExtraCtx) } if m.DiskUsage != 0 { dAtA[i] = 0x60 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.DiskUsage)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftTruncatedState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftTruncatedState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Index != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Index)) } if m.Term != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Term)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotCFFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotCFFile) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Cf) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } if m.Size_ != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Size_)) } if m.Checksum != 0 { dAtA[i] = 0x18 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Checksum)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotMeta) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.CfFiles) > 0 { for _, msg := range m.CfFiles { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.ForBalance { dAtA[i] = 0x10 i++ if m.ForBalance { dAtA[i] = 1 } else { dAtA[i] = 0 } i++ } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *SnapshotChunk) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SnapshotChunk) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Message != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Message.Size())) n7, err := m.Message.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } if len(m.Data) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Done) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Done) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *KeyValue) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftSnapshotData) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftSnapshotData) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Region != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Region.Size())) n8, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } if m.FileSize != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.FileSize)) } if len(m.Data) > 0 { for _, msg := range m.Data { dAtA[i] = 0x1a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.Version != 0 { dAtA[i] = 0x20 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Version)) } if m.Meta != nil { dAtA[i] = 0x2a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Meta.Size())) n9, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreIdent) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreIdent) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.ClusterId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.ClusterId)) } if m.StoreId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.StoreId)) } if m.ApiVersion != 0 { dAtA[i] = 0x18 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftLocalState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftLocalState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.HardState != nil { dAtA[i] = 0xa i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.HardState.Size())) n10, err := m.HardState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } if m.LastIndex != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.LastIndex)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RaftApplyState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RaftApplyState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.AppliedIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.AppliedIndex)) } if m.TruncatedState != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.TruncatedState.Size())) n11, err := m.TruncatedState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } if m.LastCommitIndex != 0 { dAtA[i] = 0x18 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.LastCommitIndex)) } if m.CommitIndex != 0 { dAtA[i] = 0x20 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.CommitIndex)) } if m.CommitTerm != 0 { dAtA[i] = 0x28 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.CommitTerm)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *MergeState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *MergeState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.MinIndex != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MinIndex)) } if m.Target != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Target.Size())) n12, err := m.Target.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } if m.Commit != 0 { dAtA[i] = 0x18 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Commit)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionLocalState) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionLocalState) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.State != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.State)) } if m.Region != nil { dAtA[i] = 0x12 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Region.Size())) n13, err := m.Region.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } if m.MergeState != nil { dAtA[i] = 0x1a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.MergeState.Size())) n14, err := m.MergeState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ExtraMessage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ExtraMessage) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Type != 0 { dAtA[i] = 0x8 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Type)) } if m.PremergeCommit != 0 { dAtA[i] = 0x10 i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.PremergeCommit)) } if len(m.CheckPeers) > 0 { for _, msg := range m.CheckPeers { dAtA[i] = 0x1a i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintRaftServerpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *RaftMessage) Size() (n int) { var l int _ = l if m.RegionId != 0 { n += 1 + sovRaftServerpb(uint64(m.RegionId)) } if m.FromPeer != nil { l = m.FromPeer.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.ToPeer != nil { l = m.ToPeer.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.Message != nil { l = m.Message.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.RegionEpoch != nil { l = m.RegionEpoch.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.IsTombstone { n += 2 } l = len(m.StartKey) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } l = len(m.EndKey) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } if m.MergeTarget != nil { l = m.MergeTarget.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.ExtraMsg != nil { l = m.ExtraMsg.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } l = len(m.ExtraCtx) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } if m.DiskUsage != 0 { n += 1 + sovRaftServerpb(uint64(m.DiskUsage)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftTruncatedState) Size() (n int) { var l int _ = l if m.Index != 0 { n += 1 + sovRaftServerpb(uint64(m.Index)) } if m.Term != 0 { n += 1 + sovRaftServerpb(uint64(m.Term)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotCFFile) Size() (n int) { var l int _ = l l = len(m.Cf) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } if m.Size_ != 0 { n += 1 + sovRaftServerpb(uint64(m.Size_)) } if m.Checksum != 0 { n += 1 + sovRaftServerpb(uint64(m.Checksum)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotMeta) Size() (n int) { var l int _ = l if len(m.CfFiles) > 0 { for _, e := range m.CfFiles { l = e.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } } if m.ForBalance { n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *SnapshotChunk) Size() (n int) { var l int _ = l if m.Message != nil { l = m.Message.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } l = len(m.Data) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Done) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *KeyValue) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftSnapshotData) Size() (n int) { var l int _ = l if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.FileSize != 0 { n += 1 + sovRaftServerpb(uint64(m.FileSize)) } if len(m.Data) > 0 { for _, e := range m.Data { l = e.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } } if m.Version != 0 { n += 1 + sovRaftServerpb(uint64(m.Version)) } if m.Meta != nil { l = m.Meta.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreIdent) Size() (n int) { var l int _ = l if m.ClusterId != 0 { n += 1 + sovRaftServerpb(uint64(m.ClusterId)) } if m.StoreId != 0 { n += 1 + sovRaftServerpb(uint64(m.StoreId)) } if m.ApiVersion != 0 { n += 1 + sovRaftServerpb(uint64(m.ApiVersion)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftLocalState) Size() (n int) { var l int _ = l if m.HardState != nil { l = m.HardState.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.LastIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.LastIndex)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RaftApplyState) Size() (n int) { var l int _ = l if m.AppliedIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.AppliedIndex)) } if m.TruncatedState != nil { l = m.TruncatedState.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.LastCommitIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.LastCommitIndex)) } if m.CommitIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.CommitIndex)) } if m.CommitTerm != 0 { n += 1 + sovRaftServerpb(uint64(m.CommitTerm)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *MergeState) Size() (n int) { var l int _ = l if m.MinIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.MinIndex)) } if m.Target != nil { l = m.Target.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.Commit != 0 { n += 1 + sovRaftServerpb(uint64(m.Commit)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionLocalState) Size() (n int) { var l int _ = l if m.State != 0 { n += 1 + sovRaftServerpb(uint64(m.State)) } if m.Region != nil { l = m.Region.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.MergeState != nil { l = m.MergeState.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ExtraMessage) Size() (n int) { var l int _ = l if m.Type != 0 { n += 1 + sovRaftServerpb(uint64(m.Type)) } if m.PremergeCommit != 0 { n += 1 + sovRaftServerpb(uint64(m.PremergeCommit)) } if len(m.CheckPeers) > 0 { for _, e := range m.CheckPeers { l = e.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovRaftServerpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozRaftServerpb(x uint64) (n int) { return sovRaftServerpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *RaftMessage) 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 ErrIntOverflowRaftServerpb } 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: RaftMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RegionId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FromPeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.FromPeer == nil { m.FromPeer = &metapb.Peer{} } if err := m.FromPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ToPeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ToPeer == nil { m.ToPeer = &metapb.Peer{} } if err := m.ToPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Message == nil { m.Message = &eraftpb.Message{} } if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.RegionEpoch == nil { m.RegionEpoch = &metapb.RegionEpoch{} } if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field IsTombstone", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.IsTombstone = bool(v != 0) case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) if m.StartKey == nil { m.StartKey = []byte{} } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) if m.EndKey == nil { m.EndKey = []byte{} } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MergeTarget", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MergeTarget == nil { m.MergeTarget = &metapb.Region{} } if err := m.MergeTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExtraMsg", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.ExtraMsg == nil { m.ExtraMsg = &ExtraMessage{} } if err := m.ExtraMsg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExtraCtx", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ExtraCtx = append(m.ExtraCtx[:0], dAtA[iNdEx:postIndex]...) if m.ExtraCtx == nil { m.ExtraCtx = []byte{} } iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DiskUsage", wireType) } m.DiskUsage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DiskUsage |= (disk_usage.DiskUsage(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *RaftTruncatedState) 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 ErrIntOverflowRaftServerpb } 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: RaftTruncatedState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftTruncatedState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Index |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Term |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *SnapshotCFFile) 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 ErrIntOverflowRaftServerpb } 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: SnapshotCFFile: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotCFFile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } 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 ErrInvalidLengthRaftServerpb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Cf = string(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 ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType) } m.Checksum = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Checksum |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *SnapshotMeta) 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 ErrIntOverflowRaftServerpb } 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: SnapshotMeta: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CfFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.CfFiles = append(m.CfFiles, &SnapshotCFFile{}) if err := m.CfFiles[len(m.CfFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ForBalance", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (int(b) & 0x7F) << shift if b < 0x80 { break } } m.ForBalance = bool(v != 0) default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *SnapshotChunk) 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 ErrIntOverflowRaftServerpb } 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: SnapshotChunk: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Message == nil { m.Message = &RaftMessage{} } if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex 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 ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen 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 := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *Done) 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 ErrIntOverflowRaftServerpb } 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: Done: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Done: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *KeyValue) 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 ErrIntOverflowRaftServerpb } 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: KeyValue: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: KeyValue: 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 byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) if m.Key == nil { m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) if m.Value == nil { m.Value = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *RaftSnapshotData) 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 ErrIntOverflowRaftServerpb } 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: RaftSnapshotData: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftSnapshotData: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FileSize", wireType) } m.FileSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FileSize |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } 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 ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data, &KeyValue{}) if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } m.Version = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Version |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Meta == nil { m.Meta = &SnapshotMeta{} } if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *StoreIdent) 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 ErrIntOverflowRaftServerpb } 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: StoreIdent: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreIdent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ClusterId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StoreId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ApiVersion |= (kvrpcpb.APIVersion(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *RaftLocalState) 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 ErrIntOverflowRaftServerpb } 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: RaftLocalState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftLocalState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HardState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.HardState == nil { m.HardState = &eraftpb.HardState{} } if err := m.HardState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LastIndex", wireType) } m.LastIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LastIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *RaftApplyState) 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 ErrIntOverflowRaftServerpb } 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: RaftApplyState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RaftApplyState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType) } m.AppliedIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.AppliedIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TruncatedState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.TruncatedState == nil { m.TruncatedState = &RaftTruncatedState{} } if err := m.TruncatedState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field LastCommitIndex", wireType) } m.LastCommitIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.LastCommitIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitIndex", wireType) } m.CommitIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CommitTerm", wireType) } m.CommitTerm = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CommitTerm |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *MergeState) 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 ErrIntOverflowRaftServerpb } 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: MergeState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MergeState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinIndex", wireType) } m.MinIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MinIndex |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Target == nil { m.Target = &metapb.Region{} } if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } m.Commit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Commit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *RegionLocalState) 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 ErrIntOverflowRaftServerpb } 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: RegionLocalState: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionLocalState: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= (PeerState(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Region == nil { m.Region = &metapb.Region{} } if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MergeState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.MergeState == nil { m.MergeState = &MergeState{} } if err := m.MergeState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 *ExtraMessage) 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 ErrIntOverflowRaftServerpb } 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: ExtraMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExtraMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= (ExtraMessageType(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PremergeCommit", wireType) } m.PremergeCommit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.PremergeCommit |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRaftServerpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthRaftServerpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.CheckPeers = append(m.CheckPeers, &metapb.Peer{}) if err := m.CheckPeers[len(m.CheckPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaftServerpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthRaftServerpb } 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 skipRaftServerpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftServerpb } 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, ErrIntOverflowRaftServerpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftServerpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthRaftServerpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowRaftServerpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipRaftServerpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthRaftServerpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowRaftServerpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("raft_serverpb.proto", fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d) } var fileDescriptor_raft_serverpb_f5cd3f7f38c0ee1d = []byte{ // 1193 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x56, 0x5b, 0x8f, 0xdb, 0x44, 0x14, 0xae, 0x93, 0x6c, 0x62, 0x1f, 0x3b, 0x59, 0x77, 0xb6, 0xa5, 0xee, 0xae, 0xba, 0xdd, 0x1a, 0x51, 0x96, 0x45, 0x04, 0x75, 0x5b, 0xa1, 0x8a, 0x07, 0xa4, 0x76, 0xdb, 0xaa, 0x4b, 0x09, 0xaa, 0xbc, 0xdb, 0x56, 0x3c, 0x59, 0x13, 0x7b, 0xe2, 0x58, 0xf1, 0x8d, 0x99, 0x49, 0xb4, 0x41, 0xfc, 0x10, 0x24, 0xde, 0x11, 0xe2, 0x97, 0xf0, 0x06, 0x8f, 0x3c, 0xa2, 0xf2, 0x0b, 0x78, 0xe4, 0x0d, 0xcd, 0xc5, 0xb9, 0xb1, 0xf4, 0x29, 0xe7, 0xf2, 0x9d, 0x39, 0xdf, 0x9c, 0xcb, 0x38, 0xb0, 0x43, 0xf1, 0x88, 0x87, 0x8c, 0xd0, 0x19, 0xa1, 0xd5, 0xb0, 0x5f, 0xd1, 0x92, 0x97, 0xa8, 0xbb, 0x66, 0xdc, 0xed, 0x12, 0xa1, 0xd7, 0xde, 0x5d, 0x27, 0x27, 0x1c, 0x2f, 0xb4, 0xee, 0x64, 0x46, 0xab, 0x68, 0xa1, 0xba, 0x71, 0xca, 0x26, 0xe1, 0x94, 0xe1, 0x84, 0x68, 0xcb, 0x36, 0x9d, 0x32, 0x2e, 0x45, 0x65, 0xf0, 0xff, 0x69, 0x82, 0x1d, 0xe0, 0x11, 0x1f, 0x10, 0x26, 0x60, 0x68, 0x0f, 0x2c, 0x4a, 0x92, 0xb4, 0x2c, 0xc2, 0x34, 0xf6, 0x8c, 0x03, 0xe3, 0xb0, 0x15, 0x98, 0xca, 0x70, 0x1a, 0xa3, 0x8f, 0xc0, 0x1a, 0xd1, 0x32, 0x0f, 0x2b, 0x42, 0xa8, 0xd7, 0x38, 0x30, 0x0e, 0xed, 0x63, 0xa7, 0xaf, 0x09, 0xbc, 0x24, 0x84, 0x06, 0xa6, 0x70, 0x0b, 0x09, 0x7d, 0x00, 0x1d, 0x5e, 0x2a, 0x60, 0xf3, 0x12, 0x60, 0x9b, 0x97, 0x12, 0x76, 0x04, 0x9d, 0x5c, 0x65, 0xf6, 0x5a, 0x12, 0xe6, 0xf6, 0xeb, 0xfb, 0x69, 0x46, 0x41, 0x0d, 0x40, 0x9f, 0x81, 0xa3, 0xa9, 0x91, 0xaa, 0x8c, 0xc6, 0xde, 0x96, 0x0c, 0xd8, 0xa9, 0xcf, 0x0d, 0xa4, 0xef, 0xa9, 0x70, 0x05, 0x36, 0x5d, 0x2a, 0xe8, 0x0e, 0x38, 0x29, 0x0b, 0x79, 0x99, 0x0f, 0x19, 0x2f, 0x0b, 0xe2, 0xb5, 0x0f, 0x8c, 0x43, 0x33, 0xb0, 0x53, 0x76, 0x5e, 0x9b, 0xc4, 0xad, 0x19, 0xc7, 0x94, 0x87, 0x13, 0x32, 0xf7, 0x3a, 0x07, 0xc6, 0xa1, 0x13, 0x98, 0xd2, 0xf0, 0x82, 0xcc, 0xd1, 0x0d, 0xe8, 0x90, 0x22, 0x96, 0x2e, 0x53, 0xba, 0xda, 0xa4, 0x88, 0x85, 0xe3, 0x1e, 0x38, 0x39, 0xa1, 0x09, 0x09, 0x39, 0xa6, 0x09, 0xe1, 0x9e, 0x25, 0x09, 0xf5, 0xd6, 0x09, 0x05, 0xb6, 0xc4, 0x9c, 0x4b, 0x08, 0x7a, 0x08, 0x16, 0xb9, 0xe0, 0x14, 0x87, 0x39, 0x4b, 0x3c, 0x90, 0xf8, 0xbd, 0xfe, 0x7a, 0xd7, 0x9f, 0x0a, 0x7f, 0x7d, 0x79, 0x53, 0xa2, 0x07, 0x2c, 0x11, 0x14, 0x55, 0x64, 0xc4, 0x2f, 0x3c, 0x5b, 0x51, 0x94, 0x86, 0x13, 0x7e, 0x81, 0x1e, 0x00, 0x2c, 0x5b, 0xed, 0x39, 0x07, 0xc6, 0x61, 0xef, 0xf8, 0x7a, 0x7f, 0xa5, 0xfb, 0x4f, 0x52, 0x36, 0x79, 0x25, 0x4f, 0xb4, 0xe2, 0x5a, 0xf4, 0xbf, 0x00, 0x24, 0x5a, 0x7f, 0x4e, 0xa7, 0x45, 0x84, 0x39, 0x89, 0xcf, 0x38, 0xe6, 0x04, 0x5d, 0x83, 0xad, 0xb4, 0x88, 0xc9, 0x85, 0xee, 0xbe, 0x52, 0x10, 0x82, 0x16, 0x27, 0x34, 0x97, 0x5d, 0x6f, 0x05, 0x52, 0xf6, 0x5f, 0x42, 0xef, 0xac, 0xc0, 0x15, 0x1b, 0x97, 0xfc, 0xe4, 0xd9, 0xb3, 0x34, 0x23, 0xa8, 0x07, 0x8d, 0x68, 0x24, 0x03, 0xad, 0xa0, 0x11, 0x8d, 0x44, 0x14, 0x4b, 0xbf, 0x23, 0x75, 0x94, 0x90, 0xd1, 0x2e, 0x98, 0xd1, 0x98, 0x44, 0x13, 0x36, 0xcd, 0xe5, 0x68, 0x74, 0x83, 0x85, 0xee, 0xa7, 0xe0, 0xd4, 0x27, 0x0e, 0x08, 0xc7, 0xe8, 0x21, 0x98, 0xd1, 0x28, 0x1c, 0xa5, 0x19, 0x61, 0x9e, 0x71, 0xd0, 0x3c, 0xb4, 0x8f, 0x6f, 0x6d, 0x54, 0x6b, 0x9d, 0x40, 0xd0, 0x89, 0x46, 0xe2, 0x97, 0xa1, 0xdb, 0x60, 0x8f, 0x4a, 0x1a, 0x0e, 0x71, 0x86, 0x8b, 0x48, 0x11, 0x30, 0x03, 0x18, 0x95, 0xf4, 0xb1, 0xb2, 0xf8, 0xdf, 0x40, 0x77, 0x11, 0x3b, 0x9e, 0x16, 0x13, 0xf4, 0x60, 0x39, 0x8a, 0x86, 0x6c, 0xcc, 0xee, 0x46, 0xaa, 0x95, 0x35, 0x59, 0x0e, 0x25, 0x82, 0x56, 0x8c, 0x39, 0x96, 0x09, 0x9c, 0x40, 0xca, 0x7e, 0x1b, 0x5a, 0x4f, 0xca, 0x82, 0xf8, 0xc7, 0x60, 0xbe, 0x20, 0xf3, 0xd7, 0x38, 0x9b, 0x12, 0xe4, 0x42, 0x53, 0x0c, 0x90, 0x21, 0x61, 0x42, 0x14, 0x75, 0x9e, 0x09, 0x97, 0x0e, 0x55, 0x8a, 0xff, 0x9b, 0x01, 0xae, 0x48, 0x54, 0x73, 0x7b, 0x82, 0x39, 0x46, 0x77, 0xa1, 0xad, 0x06, 0x5a, 0x33, 0xdb, 0x1c, 0x31, 0xed, 0x15, 0x33, 0x22, 0x6a, 0x15, 0xae, 0xd4, 0xdc, 0x14, 0x86, 0x33, 0x51, 0xf7, 0x8f, 0x35, 0xd3, 0xa6, 0xac, 0xe3, 0x8d, 0x8d, 0xcb, 0xd5, 0x44, 0xd5, 0x15, 0x90, 0x07, 0x9d, 0x19, 0xa1, 0x4c, 0xa4, 0x6c, 0xc9, 0x73, 0x6a, 0x15, 0x7d, 0x0a, 0x2d, 0x91, 0x5c, 0x6f, 0xdf, 0xde, 0xff, 0xb4, 0x43, 0x74, 0x2f, 0x90, 0x40, 0xff, 0x7b, 0x80, 0x33, 0x5e, 0x52, 0x72, 0x1a, 0x93, 0x82, 0xa3, 0x5b, 0x00, 0x51, 0x36, 0x65, 0x9c, 0xd0, 0xe5, 0x03, 0x63, 0x69, 0xcb, 0x69, 0x8c, 0x6e, 0x82, 0xc9, 0x04, 0x58, 0x38, 0xd5, 0x05, 0x3a, 0x4c, 0x05, 0xa3, 0x07, 0x60, 0xe3, 0x2a, 0x0d, 0x6b, 0x5a, 0x4d, 0x39, 0xe4, 0x3b, 0xfd, 0xfa, 0xc5, 0x7b, 0xf4, 0xf2, 0xf4, 0xb5, 0x72, 0x05, 0x80, 0xab, 0x54, 0xcb, 0xfe, 0x10, 0x7a, 0xa2, 0x9c, 0x5f, 0x95, 0x11, 0xce, 0xd4, 0x7c, 0xdf, 0x03, 0x18, 0x63, 0x1a, 0x87, 0x4c, 0x68, 0xba, 0xa0, 0x68, 0xf1, 0xea, 0x3c, 0xc7, 0x54, 0xed, 0x41, 0x60, 0x8d, 0x6b, 0x51, 0x90, 0xce, 0x30, 0xe3, 0xa1, 0xda, 0x0b, 0xc5, 0xcb, 0x12, 0x96, 0x53, 0x61, 0xf0, 0xff, 0x36, 0x54, 0x92, 0x47, 0x55, 0x95, 0xcd, 0x55, 0xc4, 0xfb, 0xd0, 0xc5, 0x55, 0x95, 0xa5, 0x24, 0x0e, 0x57, 0x97, 0xc9, 0xd1, 0x46, 0x19, 0x87, 0xbe, 0x84, 0x6d, 0x5e, 0xef, 0x9e, 0xa6, 0xa3, 0x1e, 0xd5, 0x3b, 0x97, 0x4c, 0xde, 0xfa, 0x96, 0x06, 0x3d, 0xbe, 0xbe, 0xb5, 0x47, 0x70, 0x55, 0x52, 0x8c, 0xca, 0x3c, 0x4f, 0x6b, 0xa6, 0x4d, 0x99, 0x74, 0x5b, 0x38, 0x4e, 0xa4, 0x5d, 0xe5, 0xbd, 0x03, 0xce, 0x1a, 0x4c, 0x75, 0xd8, 0x8e, 0x56, 0x20, 0xb7, 0x41, 0xab, 0xa1, 0xdc, 0xfa, 0x2d, 0x89, 0x00, 0x65, 0x3a, 0x17, 0xbb, 0x9f, 0x02, 0x0c, 0xc4, 0xbb, 0xa6, 0xb2, 0xef, 0x81, 0x95, 0xa7, 0xc5, 0xda, 0x55, 0xcd, 0x3c, 0x2d, 0xd4, 0x59, 0x77, 0xa1, 0xad, 0x1f, 0xc8, 0xc6, 0xe5, 0xd3, 0xab, 0xbc, 0xe8, 0x3d, 0x68, 0xab, 0x04, 0x9a, 0xb7, 0xd6, 0xfc, 0x9f, 0xc4, 0x4a, 0x48, 0xe8, 0x4a, 0x17, 0xfb, 0xb0, 0xb5, 0x6c, 0x60, 0xef, 0xd8, 0xdb, 0xa8, 0x98, 0xf8, 0xb8, 0xa8, 0x42, 0x29, 0xd8, 0xca, 0x0a, 0x35, 0xde, 0xb9, 0x42, 0x9f, 0x83, 0x7a, 0xaf, 0x75, 0x3f, 0xd4, 0xb7, 0xeb, 0xe6, 0xc6, 0xe9, 0xcb, 0x9b, 0x07, 0x90, 0x2f, 0x64, 0xff, 0x47, 0x03, 0x9c, 0xd5, 0xd7, 0x1b, 0xdd, 0x87, 0x16, 0x9f, 0x57, 0x35, 0xc7, 0xdb, 0xef, 0x78, 0xe8, 0xcf, 0xe7, 0x15, 0x09, 0x24, 0x18, 0x7d, 0x08, 0xdb, 0x15, 0x25, 0x8a, 0x84, 0xae, 0x87, 0x9a, 0xb8, 0x5e, 0x6d, 0x56, 0xbd, 0x44, 0x9f, 0x80, 0x2d, 0x1f, 0x4e, 0xf9, 0x95, 0x65, 0x7a, 0xaf, 0xd7, 0x3f, 0xb3, 0x20, 0x01, 0x42, 0x64, 0x47, 0x8f, 0xc0, 0x5a, 0x54, 0x05, 0x01, 0xb4, 0xbf, 0x2e, 0x69, 0x8e, 0x33, 0xf7, 0x0a, 0x72, 0xc0, 0x94, 0x93, 0x9b, 0x16, 0x89, 0x6b, 0xa0, 0x2e, 0x58, 0x8b, 0xef, 0xa2, 0xdb, 0x40, 0x36, 0x74, 0xc4, 0x6d, 0x85, 0xaf, 0x79, 0xf4, 0x8b, 0x01, 0xee, 0x26, 0x6b, 0xb4, 0x03, 0xdb, 0x03, 0x96, 0xa8, 0x32, 0xbe, 0xc1, 0x13, 0xf2, 0xaa, 0x72, 0xaf, 0x20, 0x0f, 0xae, 0x0d, 0x58, 0xf2, 0x06, 0x17, 0x3c, 0x28, 0xb3, 0x6c, 0x88, 0xa3, 0x89, 0xac, 0x99, 0x6b, 0xa0, 0xeb, 0x70, 0x75, 0xc0, 0x92, 0x13, 0xc1, 0xeb, 0x8c, 0xe3, 0x8c, 0x08, 0x4e, 0x6e, 0x03, 0xdd, 0x82, 0x9b, 0xff, 0x31, 0x07, 0x84, 0x55, 0x65, 0xc1, 0x88, 0xdb, 0x44, 0x37, 0x60, 0x67, 0xc0, 0x92, 0xe7, 0xe9, 0x90, 0xd0, 0x42, 0x94, 0x9d, 0x7c, 0x3b, 0x25, 0x8c, 0xbb, 0x2d, 0x9d, 0x68, 0xc5, 0xa1, 0x43, 0xb6, 0x1e, 0xdf, 0xfd, 0xe3, 0x67, 0xd3, 0xf8, 0xf5, 0xed, 0xbe, 0xf1, 0xfb, 0xdb, 0x7d, 0xe3, 0xcf, 0xb7, 0xfb, 0xc6, 0x0f, 0x7f, 0xed, 0x5f, 0x01, 0xb7, 0xa4, 0x49, 0x9f, 0xa7, 0x93, 0x59, 0x7f, 0x32, 0x93, 0xff, 0x80, 0x86, 0x6d, 0xf9, 0x73, 0xff, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x47, 0xa7, 0x16, 0x95, 0x7d, 0x09, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/replication_modepb/000077500000000000000000000000001421456440000207255ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/replication_modepb/replication_modepb.pb.go000066400000000000000000001010451421456440000255140ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: replication_modepb.proto package replication_modepb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type ReplicationMode int32 const ( // The standard mode. Replicate logs to majority peer. ReplicationMode_MAJORITY ReplicationMode = 0 // DR mode. Replicate logs among 2 DCs. ReplicationMode_DR_AUTO_SYNC ReplicationMode = 1 ) var ReplicationMode_name = map[int32]string{ 0: "MAJORITY", 1: "DR_AUTO_SYNC", } var ReplicationMode_value = map[string]int32{ "MAJORITY": 0, "DR_AUTO_SYNC": 1, } func (x ReplicationMode) String() string { return proto.EnumName(ReplicationMode_name, int32(x)) } func (ReplicationMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{0} } type DRAutoSyncState int32 const ( // Raft logs need to sync between different DCs DRAutoSyncState_SYNC DRAutoSyncState = 0 // Wait for switching to ASYNC. Stop sync raft logs between DCs. DRAutoSyncState_ASYNC_WAIT DRAutoSyncState = 1 // Raft logs need to sync to majority peers DRAutoSyncState_ASYNC DRAutoSyncState = 2 // Switching from ASYNC to SYNC mode DRAutoSyncState_SYNC_RECOVER DRAutoSyncState = 3 ) var DRAutoSyncState_name = map[int32]string{ 0: "SYNC", 1: "ASYNC_WAIT", 2: "ASYNC", 3: "SYNC_RECOVER", } var DRAutoSyncState_value = map[string]int32{ "SYNC": 0, "ASYNC_WAIT": 1, "ASYNC": 2, "SYNC_RECOVER": 3, } func (x DRAutoSyncState) String() string { return proto.EnumName(DRAutoSyncState_name, int32(x)) } func (DRAutoSyncState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{1} } type RegionReplicationState int32 const ( // The region's state is unknown RegionReplicationState_UNKNOWN RegionReplicationState = 0 // Logs sync to majority peers RegionReplicationState_SIMPLE_MAJORITY RegionReplicationState = 1 // Logs sync to different DCs RegionReplicationState_INTEGRITY_OVER_LABEL RegionReplicationState = 2 ) var RegionReplicationState_name = map[int32]string{ 0: "UNKNOWN", 1: "SIMPLE_MAJORITY", 2: "INTEGRITY_OVER_LABEL", } var RegionReplicationState_value = map[string]int32{ "UNKNOWN": 0, "SIMPLE_MAJORITY": 1, "INTEGRITY_OVER_LABEL": 2, } func (x RegionReplicationState) String() string { return proto.EnumName(RegionReplicationState_name, int32(x)) } func (RegionReplicationState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{2} } // The replication status sync from PD to TiKV. type ReplicationStatus struct { Mode ReplicationMode `protobuf:"varint,1,opt,name=mode,proto3,enum=replication_modepb.ReplicationMode" json:"mode,omitempty"` DrAutoSync *DRAutoSync `protobuf:"bytes,2,opt,name=dr_auto_sync,json=drAutoSync" json:"dr_auto_sync,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReplicationStatus) Reset() { *m = ReplicationStatus{} } func (m *ReplicationStatus) String() string { return proto.CompactTextString(m) } func (*ReplicationStatus) ProtoMessage() {} func (*ReplicationStatus) Descriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{0} } func (m *ReplicationStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReplicationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReplicationStatus.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ReplicationStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_ReplicationStatus.Merge(dst, src) } func (m *ReplicationStatus) XXX_Size() int { return m.Size() } func (m *ReplicationStatus) XXX_DiscardUnknown() { xxx_messageInfo_ReplicationStatus.DiscardUnknown(m) } var xxx_messageInfo_ReplicationStatus proto.InternalMessageInfo func (m *ReplicationStatus) GetMode() ReplicationMode { if m != nil { return m.Mode } return ReplicationMode_MAJORITY } func (m *ReplicationStatus) GetDrAutoSync() *DRAutoSync { if m != nil { return m.DrAutoSync } return nil } // The status of dr-autosync mode. type DRAutoSync struct { // The key of the label that used for distinguish different DC. LabelKey string `protobuf:"bytes,1,opt,name=label_key,json=labelKey,proto3" json:"label_key,omitempty"` State DRAutoSyncState `protobuf:"varint,2,opt,name=state,proto3,enum=replication_modepb.DRAutoSyncState" json:"state,omitempty"` // Unique ID of the state, it increases after each state transfer. StateId uint64 `protobuf:"varint,3,opt,name=state_id,json=stateId,proto3" json:"state_id,omitempty"` // Duration to wait before switching to SYNC by force (in seconds) WaitSyncTimeoutHint int32 `protobuf:"varint,4,opt,name=wait_sync_timeout_hint,json=waitSyncTimeoutHint,proto3" json:"wait_sync_timeout_hint,omitempty"` // Stores should only sync messages with available stores when state is ASYNC or ASYNC_WAIT. AvailableStores []uint64 `protobuf:"varint,5,rep,packed,name=available_stores,json=availableStores" json:"available_stores,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DRAutoSync) Reset() { *m = DRAutoSync{} } func (m *DRAutoSync) String() string { return proto.CompactTextString(m) } func (*DRAutoSync) ProtoMessage() {} func (*DRAutoSync) Descriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{1} } func (m *DRAutoSync) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DRAutoSync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DRAutoSync.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *DRAutoSync) XXX_Merge(src proto.Message) { xxx_messageInfo_DRAutoSync.Merge(dst, src) } func (m *DRAutoSync) XXX_Size() int { return m.Size() } func (m *DRAutoSync) XXX_DiscardUnknown() { xxx_messageInfo_DRAutoSync.DiscardUnknown(m) } var xxx_messageInfo_DRAutoSync proto.InternalMessageInfo func (m *DRAutoSync) GetLabelKey() string { if m != nil { return m.LabelKey } return "" } func (m *DRAutoSync) GetState() DRAutoSyncState { if m != nil { return m.State } return DRAutoSyncState_SYNC } func (m *DRAutoSync) GetStateId() uint64 { if m != nil { return m.StateId } return 0 } func (m *DRAutoSync) GetWaitSyncTimeoutHint() int32 { if m != nil { return m.WaitSyncTimeoutHint } return 0 } func (m *DRAutoSync) GetAvailableStores() []uint64 { if m != nil { return m.AvailableStores } return nil } // The replication status sync from TiKV to PD. type RegionReplicationStatus struct { State RegionReplicationState `protobuf:"varint,1,opt,name=state,proto3,enum=replication_modepb.RegionReplicationState" json:"state,omitempty"` // Unique ID of the state, it increases after each state transfer. StateId uint64 `protobuf:"varint,2,opt,name=state_id,json=stateId,proto3" json:"state_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RegionReplicationStatus) Reset() { *m = RegionReplicationStatus{} } func (m *RegionReplicationStatus) String() string { return proto.CompactTextString(m) } func (*RegionReplicationStatus) ProtoMessage() {} func (*RegionReplicationStatus) Descriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{2} } func (m *RegionReplicationStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RegionReplicationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RegionReplicationStatus.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RegionReplicationStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_RegionReplicationStatus.Merge(dst, src) } func (m *RegionReplicationStatus) XXX_Size() int { return m.Size() } func (m *RegionReplicationStatus) XXX_DiscardUnknown() { xxx_messageInfo_RegionReplicationStatus.DiscardUnknown(m) } var xxx_messageInfo_RegionReplicationStatus proto.InternalMessageInfo func (m *RegionReplicationStatus) GetState() RegionReplicationState { if m != nil { return m.State } return RegionReplicationState_UNKNOWN } func (m *RegionReplicationStatus) GetStateId() uint64 { if m != nil { return m.StateId } return 0 } type StoreDRAutoSyncStatus struct { State DRAutoSyncState `protobuf:"varint,1,opt,name=state,proto3,enum=replication_modepb.DRAutoSyncState" json:"state,omitempty"` StateId uint64 `protobuf:"varint,2,opt,name=state_id,json=stateId,proto3" json:"state_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StoreDRAutoSyncStatus) Reset() { *m = StoreDRAutoSyncStatus{} } func (m *StoreDRAutoSyncStatus) String() string { return proto.CompactTextString(m) } func (*StoreDRAutoSyncStatus) ProtoMessage() {} func (*StoreDRAutoSyncStatus) Descriptor() ([]byte, []int) { return fileDescriptor_replication_modepb_790b765dc1f2f6d6, []int{3} } func (m *StoreDRAutoSyncStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StoreDRAutoSyncStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StoreDRAutoSyncStatus.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *StoreDRAutoSyncStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_StoreDRAutoSyncStatus.Merge(dst, src) } func (m *StoreDRAutoSyncStatus) XXX_Size() int { return m.Size() } func (m *StoreDRAutoSyncStatus) XXX_DiscardUnknown() { xxx_messageInfo_StoreDRAutoSyncStatus.DiscardUnknown(m) } var xxx_messageInfo_StoreDRAutoSyncStatus proto.InternalMessageInfo func (m *StoreDRAutoSyncStatus) GetState() DRAutoSyncState { if m != nil { return m.State } return DRAutoSyncState_SYNC } func (m *StoreDRAutoSyncStatus) GetStateId() uint64 { if m != nil { return m.StateId } return 0 } func init() { proto.RegisterType((*ReplicationStatus)(nil), "replication_modepb.ReplicationStatus") proto.RegisterType((*DRAutoSync)(nil), "replication_modepb.DRAutoSync") proto.RegisterType((*RegionReplicationStatus)(nil), "replication_modepb.RegionReplicationStatus") proto.RegisterType((*StoreDRAutoSyncStatus)(nil), "replication_modepb.StoreDRAutoSyncStatus") proto.RegisterEnum("replication_modepb.ReplicationMode", ReplicationMode_name, ReplicationMode_value) proto.RegisterEnum("replication_modepb.DRAutoSyncState", DRAutoSyncState_name, DRAutoSyncState_value) proto.RegisterEnum("replication_modepb.RegionReplicationState", RegionReplicationState_name, RegionReplicationState_value) } func (m *ReplicationStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ReplicationStatus) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Mode != 0 { dAtA[i] = 0x8 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.Mode)) } if m.DrAutoSync != nil { dAtA[i] = 0x12 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.DrAutoSync.Size())) n1, err := m.DrAutoSync.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *DRAutoSync) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *DRAutoSync) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.LabelKey) > 0 { dAtA[i] = 0xa i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(len(m.LabelKey))) i += copy(dAtA[i:], m.LabelKey) } if m.State != 0 { dAtA[i] = 0x10 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.State)) } if m.StateId != 0 { dAtA[i] = 0x18 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.StateId)) } if m.WaitSyncTimeoutHint != 0 { dAtA[i] = 0x20 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.WaitSyncTimeoutHint)) } if len(m.AvailableStores) > 0 { dAtA3 := make([]byte, len(m.AvailableStores)*10) var j2 int for _, num := range m.AvailableStores { for num >= 1<<7 { dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j2++ } dAtA3[j2] = uint8(num) j2++ } dAtA[i] = 0x2a i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(j2)) i += copy(dAtA[i:], dAtA3[:j2]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *RegionReplicationStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RegionReplicationStatus) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.State != 0 { dAtA[i] = 0x8 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.State)) } if m.StateId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.StateId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *StoreDRAutoSyncStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StoreDRAutoSyncStatus) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.State != 0 { dAtA[i] = 0x8 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.State)) } if m.StateId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintReplicationModepb(dAtA, i, uint64(m.StateId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintReplicationModepb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *ReplicationStatus) Size() (n int) { var l int _ = l if m.Mode != 0 { n += 1 + sovReplicationModepb(uint64(m.Mode)) } if m.DrAutoSync != nil { l = m.DrAutoSync.Size() n += 1 + l + sovReplicationModepb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *DRAutoSync) Size() (n int) { var l int _ = l l = len(m.LabelKey) if l > 0 { n += 1 + l + sovReplicationModepb(uint64(l)) } if m.State != 0 { n += 1 + sovReplicationModepb(uint64(m.State)) } if m.StateId != 0 { n += 1 + sovReplicationModepb(uint64(m.StateId)) } if m.WaitSyncTimeoutHint != 0 { n += 1 + sovReplicationModepb(uint64(m.WaitSyncTimeoutHint)) } if len(m.AvailableStores) > 0 { l = 0 for _, e := range m.AvailableStores { l += sovReplicationModepb(uint64(e)) } n += 1 + sovReplicationModepb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RegionReplicationStatus) Size() (n int) { var l int _ = l if m.State != 0 { n += 1 + sovReplicationModepb(uint64(m.State)) } if m.StateId != 0 { n += 1 + sovReplicationModepb(uint64(m.StateId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *StoreDRAutoSyncStatus) Size() (n int) { var l int _ = l if m.State != 0 { n += 1 + sovReplicationModepb(uint64(m.State)) } if m.StateId != 0 { n += 1 + sovReplicationModepb(uint64(m.StateId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovReplicationModepb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozReplicationModepb(x uint64) (n int) { return sovReplicationModepb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *ReplicationStatus) 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 ErrIntOverflowReplicationModepb } 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: ReplicationStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) } m.Mode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Mode |= (ReplicationMode(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DrAutoSync", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthReplicationModepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.DrAutoSync == nil { m.DrAutoSync = &DRAutoSync{} } if err := m.DrAutoSync.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipReplicationModepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthReplicationModepb } 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 *DRAutoSync) 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 ErrIntOverflowReplicationModepb } 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: DRAutoSync: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DRAutoSync: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } 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 ErrInvalidLengthReplicationModepb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.LabelKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= (DRAutoSyncState(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) } m.StateId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StateId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WaitSyncTimeoutHint", wireType) } m.WaitSyncTimeoutHint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WaitSyncTimeoutHint |= (int32(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.AvailableStores = append(m.AvailableStores, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthReplicationModepb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.AvailableStores = append(m.AvailableStores, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field AvailableStores", wireType) } default: iNdEx = preIndex skippy, err := skipReplicationModepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthReplicationModepb } 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 *RegionReplicationStatus) 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 ErrIntOverflowReplicationModepb } 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: RegionReplicationStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RegionReplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= (RegionReplicationState(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) } m.StateId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StateId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipReplicationModepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthReplicationModepb } 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 *StoreDRAutoSyncStatus) 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 ErrIntOverflowReplicationModepb } 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: StoreDRAutoSyncStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StoreDRAutoSyncStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= (DRAutoSyncState(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) } m.StateId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowReplicationModepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StateId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipReplicationModepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthReplicationModepb } 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 skipReplicationModepb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowReplicationModepb } 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, ErrIntOverflowReplicationModepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowReplicationModepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthReplicationModepb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowReplicationModepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipReplicationModepb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthReplicationModepb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowReplicationModepb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("replication_modepb.proto", fileDescriptor_replication_modepb_790b765dc1f2f6d6) } var fileDescriptor_replication_modepb_790b765dc1f2f6d6 = []byte{ // 474 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0x4d, 0x6f, 0xd3, 0x40, 0x10, 0xcd, 0xe6, 0x83, 0x26, 0xd3, 0xa8, 0x59, 0xb6, 0x50, 0x8c, 0x90, 0x2c, 0x2b, 0x5c, 0x4c, 0x0e, 0x95, 0x68, 0x0f, 0x88, 0x5b, 0xdd, 0xd6, 0xa2, 0xa6, 0x89, 0x83, 0xd6, 0x2e, 0x55, 0x4f, 0x2b, 0x27, 0x5e, 0xc1, 0x0a, 0xc7, 0x1b, 0xd9, 0xeb, 0xa2, 0xfc, 0x09, 0xce, 0xfc, 0x24, 0x8e, 0xfc, 0x03, 0x50, 0xf8, 0x23, 0xc8, 0x1b, 0xb5, 0x21, 0xad, 0x39, 0xf5, 0x36, 0x33, 0x4f, 0xf3, 0xe6, 0xbd, 0xa7, 0x5d, 0x30, 0x32, 0x3e, 0x4f, 0xc4, 0x34, 0x52, 0x42, 0xa6, 0x6c, 0x26, 0x63, 0x3e, 0x9f, 0xec, 0xcf, 0x33, 0xa9, 0x24, 0x21, 0xf7, 0x91, 0xfe, 0x37, 0x04, 0x8f, 0xe9, 0x7a, 0x1c, 0xa8, 0x48, 0x15, 0x39, 0x79, 0x03, 0xcd, 0x12, 0x37, 0x90, 0x85, 0xec, 0x9d, 0x83, 0x97, 0xfb, 0x15, 0x94, 0xff, 0x2c, 0x8d, 0x64, 0xcc, 0xa9, 0x5e, 0x20, 0x47, 0xd0, 0x8d, 0x33, 0x16, 0x15, 0x4a, 0xb2, 0x7c, 0x91, 0x4e, 0x8d, 0xba, 0x85, 0xec, 0xed, 0x03, 0xb3, 0x8a, 0xe0, 0x94, 0x3a, 0x85, 0x92, 0xc1, 0x22, 0x9d, 0x52, 0x88, 0xb3, 0x9b, 0xba, 0xff, 0x0b, 0x01, 0xac, 0x21, 0xf2, 0x02, 0x3a, 0x49, 0x34, 0xe1, 0x09, 0xfb, 0xc2, 0x17, 0x5a, 0x4e, 0x87, 0xb6, 0xf5, 0xe0, 0x9c, 0x2f, 0xc8, 0x5b, 0x68, 0xe5, 0x2a, 0x52, 0x5c, 0x9f, 0xf9, 0x8f, 0xce, 0x35, 0x57, 0xe9, 0x8d, 0xd3, 0xd5, 0x06, 0x79, 0x0e, 0x6d, 0x5d, 0x30, 0x11, 0x1b, 0x0d, 0x0b, 0xd9, 0x4d, 0xba, 0xa5, 0x7b, 0x2f, 0x26, 0x87, 0xb0, 0xf7, 0x35, 0x12, 0x4a, 0x1b, 0x60, 0x4a, 0xcc, 0xb8, 0x2c, 0x14, 0xfb, 0x2c, 0x52, 0x65, 0x34, 0x2d, 0x64, 0xb7, 0xe8, 0x6e, 0x89, 0x96, 0x84, 0xe1, 0x0a, 0x3b, 0x13, 0xa9, 0x22, 0xaf, 0x00, 0x47, 0xd7, 0x91, 0x48, 0xa2, 0x49, 0xc2, 0x59, 0xae, 0x64, 0xc6, 0x73, 0xa3, 0x65, 0x35, 0xec, 0x26, 0xed, 0xdd, 0xce, 0x03, 0x3d, 0xee, 0x5f, 0xc3, 0x33, 0xca, 0x3f, 0x09, 0x99, 0xde, 0xcf, 0xfd, 0xe8, 0xc6, 0xd0, 0x2a, 0xf8, 0x41, 0x75, 0xf0, 0x15, 0xbb, 0x95, 0xbe, 0xea, 0x1b, 0xbe, 0xfa, 0x33, 0x78, 0xaa, 0x15, 0x6c, 0x26, 0x52, 0xe4, 0xeb, 0x18, 0xd1, 0x83, 0x62, 0xdc, 0x3c, 0x37, 0x78, 0x0d, 0xbd, 0x3b, 0x6f, 0x84, 0x74, 0xa1, 0x3d, 0x72, 0xde, 0x8f, 0xa9, 0x17, 0x5e, 0xe1, 0x1a, 0xc1, 0xd0, 0x3d, 0xa5, 0xcc, 0xb9, 0x08, 0xc7, 0x2c, 0xb8, 0xf2, 0x4f, 0x30, 0x1a, 0x9c, 0x41, 0xef, 0xce, 0x1d, 0xd2, 0x86, 0xa6, 0x06, 0x6b, 0x64, 0x07, 0xc0, 0x29, 0x4b, 0x76, 0xe9, 0x78, 0x21, 0x46, 0xa4, 0x03, 0x2d, 0xdd, 0xe3, 0x7a, 0xc9, 0xa4, 0x11, 0xea, 0x9e, 0x8c, 0x3f, 0xba, 0x14, 0x37, 0x06, 0x21, 0xec, 0x55, 0xe7, 0x44, 0xb6, 0x61, 0xeb, 0xc2, 0x3f, 0xf7, 0xc7, 0x97, 0x3e, 0xae, 0x91, 0x5d, 0xe8, 0x05, 0xde, 0xe8, 0xc3, 0xd0, 0x65, 0xb7, 0xba, 0x10, 0x31, 0xe0, 0x89, 0xe7, 0x87, 0xee, 0xbb, 0xb2, 0x65, 0x25, 0x1f, 0x1b, 0x3a, 0xc7, 0xee, 0x10, 0xd7, 0x8f, 0xf1, 0x8f, 0xa5, 0x89, 0x7e, 0x2e, 0x4d, 0xf4, 0x7b, 0x69, 0xa2, 0xef, 0x7f, 0xcc, 0xda, 0xe4, 0x91, 0xfe, 0x59, 0x87, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xcd, 0x87, 0xeb, 0x75, 0x03, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/resource_usage_agent/000077500000000000000000000000001421456440000212575ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/resource_usage_agent/resource_usage_agent.pb.go000066400000000000000000001120751421456440000264050ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: resource_usage_agent.proto package resource_usage_agent import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type ResourceMeteringRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResourceMeteringRequest) Reset() { *m = ResourceMeteringRequest{} } func (m *ResourceMeteringRequest) String() string { return proto.CompactTextString(m) } func (*ResourceMeteringRequest) ProtoMessage() {} func (*ResourceMeteringRequest) Descriptor() ([]byte, []int) { return fileDescriptor_resource_usage_agent_8426a9d1c2864a7c, []int{0} } func (m *ResourceMeteringRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResourceMeteringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResourceMeteringRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResourceMeteringRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ResourceMeteringRequest.Merge(dst, src) } func (m *ResourceMeteringRequest) XXX_Size() int { return m.Size() } func (m *ResourceMeteringRequest) XXX_DiscardUnknown() { xxx_messageInfo_ResourceMeteringRequest.DiscardUnknown(m) } var xxx_messageInfo_ResourceMeteringRequest proto.InternalMessageInfo type EmptyResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *EmptyResponse) Reset() { *m = EmptyResponse{} } func (m *EmptyResponse) String() string { return proto.CompactTextString(m) } func (*EmptyResponse) ProtoMessage() {} func (*EmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptor_resource_usage_agent_8426a9d1c2864a7c, []int{1} } func (m *EmptyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *EmptyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_EmptyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *EmptyResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_EmptyResponse.Merge(dst, src) } func (m *EmptyResponse) XXX_Size() int { return m.Size() } func (m *EmptyResponse) XXX_DiscardUnknown() { xxx_messageInfo_EmptyResponse.DiscardUnknown(m) } var xxx_messageInfo_EmptyResponse proto.InternalMessageInfo type ResourceUsageRecord struct { // Types that are valid to be assigned to RecordOneof: // *ResourceUsageRecord_Record RecordOneof isResourceUsageRecord_RecordOneof `protobuf_oneof:"record_oneof"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ResourceUsageRecord) Reset() { *m = ResourceUsageRecord{} } func (m *ResourceUsageRecord) String() string { return proto.CompactTextString(m) } func (*ResourceUsageRecord) ProtoMessage() {} func (*ResourceUsageRecord) Descriptor() ([]byte, []int) { return fileDescriptor_resource_usage_agent_8426a9d1c2864a7c, []int{2} } func (m *ResourceUsageRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ResourceUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ResourceUsageRecord.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *ResourceUsageRecord) XXX_Merge(src proto.Message) { xxx_messageInfo_ResourceUsageRecord.Merge(dst, src) } func (m *ResourceUsageRecord) XXX_Size() int { return m.Size() } func (m *ResourceUsageRecord) XXX_DiscardUnknown() { xxx_messageInfo_ResourceUsageRecord.DiscardUnknown(m) } var xxx_messageInfo_ResourceUsageRecord proto.InternalMessageInfo type isResourceUsageRecord_RecordOneof interface { isResourceUsageRecord_RecordOneof() MarshalTo([]byte) (int, error) Size() int } type ResourceUsageRecord_Record struct { Record *GroupTagRecord `protobuf:"bytes,1,opt,name=record,oneof"` } func (*ResourceUsageRecord_Record) isResourceUsageRecord_RecordOneof() {} func (m *ResourceUsageRecord) GetRecordOneof() isResourceUsageRecord_RecordOneof { if m != nil { return m.RecordOneof } return nil } func (m *ResourceUsageRecord) GetRecord() *GroupTagRecord { if x, ok := m.GetRecordOneof().(*ResourceUsageRecord_Record); ok { return x.Record } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*ResourceUsageRecord) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _ResourceUsageRecord_OneofMarshaler, _ResourceUsageRecord_OneofUnmarshaler, _ResourceUsageRecord_OneofSizer, []interface{}{ (*ResourceUsageRecord_Record)(nil), } } func _ResourceUsageRecord_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*ResourceUsageRecord) // record_oneof switch x := m.RecordOneof.(type) { case *ResourceUsageRecord_Record: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Record); err != nil { return err } case nil: default: return fmt.Errorf("ResourceUsageRecord.RecordOneof has unexpected type %T", x) } return nil } func _ResourceUsageRecord_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*ResourceUsageRecord) switch tag { case 1: // record_oneof.record if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(GroupTagRecord) err := b.DecodeMessage(msg) m.RecordOneof = &ResourceUsageRecord_Record{msg} return true, err default: return false, nil } } func _ResourceUsageRecord_OneofSizer(msg proto.Message) (n int) { m := msg.(*ResourceUsageRecord) // record_oneof switch x := m.RecordOneof.(type) { case *ResourceUsageRecord_Record: s := proto.Size(x.Record) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } // GroupTagRecord is a set of resource usage data grouped by resource_group_tag. type GroupTagRecord struct { ResourceGroupTag []byte `protobuf:"bytes,1,opt,name=resource_group_tag,json=resourceGroupTag,proto3" json:"resource_group_tag,omitempty"` Items []*GroupTagRecordItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GroupTagRecord) Reset() { *m = GroupTagRecord{} } func (m *GroupTagRecord) String() string { return proto.CompactTextString(m) } func (*GroupTagRecord) ProtoMessage() {} func (*GroupTagRecord) Descriptor() ([]byte, []int) { return fileDescriptor_resource_usage_agent_8426a9d1c2864a7c, []int{3} } func (m *GroupTagRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GroupTagRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GroupTagRecord.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GroupTagRecord) XXX_Merge(src proto.Message) { xxx_messageInfo_GroupTagRecord.Merge(dst, src) } func (m *GroupTagRecord) XXX_Size() int { return m.Size() } func (m *GroupTagRecord) XXX_DiscardUnknown() { xxx_messageInfo_GroupTagRecord.DiscardUnknown(m) } var xxx_messageInfo_GroupTagRecord proto.InternalMessageInfo func (m *GroupTagRecord) GetResourceGroupTag() []byte { if m != nil { return m.ResourceGroupTag } return nil } func (m *GroupTagRecord) GetItems() []*GroupTagRecordItem { if m != nil { return m.Items } return nil } type GroupTagRecordItem struct { TimestampSec uint64 `protobuf:"varint,1,opt,name=timestamp_sec,json=timestampSec,proto3" json:"timestamp_sec,omitempty"` CpuTimeMs uint32 `protobuf:"varint,2,opt,name=cpu_time_ms,json=cpuTimeMs,proto3" json:"cpu_time_ms,omitempty"` ReadKeys uint32 `protobuf:"varint,3,opt,name=read_keys,json=readKeys,proto3" json:"read_keys,omitempty"` WriteKeys uint32 `protobuf:"varint,4,opt,name=write_keys,json=writeKeys,proto3" json:"write_keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GroupTagRecordItem) Reset() { *m = GroupTagRecordItem{} } func (m *GroupTagRecordItem) String() string { return proto.CompactTextString(m) } func (*GroupTagRecordItem) ProtoMessage() {} func (*GroupTagRecordItem) Descriptor() ([]byte, []int) { return fileDescriptor_resource_usage_agent_8426a9d1c2864a7c, []int{4} } func (m *GroupTagRecordItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GroupTagRecordItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GroupTagRecordItem.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *GroupTagRecordItem) XXX_Merge(src proto.Message) { xxx_messageInfo_GroupTagRecordItem.Merge(dst, src) } func (m *GroupTagRecordItem) XXX_Size() int { return m.Size() } func (m *GroupTagRecordItem) XXX_DiscardUnknown() { xxx_messageInfo_GroupTagRecordItem.DiscardUnknown(m) } var xxx_messageInfo_GroupTagRecordItem proto.InternalMessageInfo func (m *GroupTagRecordItem) GetTimestampSec() uint64 { if m != nil { return m.TimestampSec } return 0 } func (m *GroupTagRecordItem) GetCpuTimeMs() uint32 { if m != nil { return m.CpuTimeMs } return 0 } func (m *GroupTagRecordItem) GetReadKeys() uint32 { if m != nil { return m.ReadKeys } return 0 } func (m *GroupTagRecordItem) GetWriteKeys() uint32 { if m != nil { return m.WriteKeys } return 0 } func init() { proto.RegisterType((*ResourceMeteringRequest)(nil), "resource_usage_agent.ResourceMeteringRequest") proto.RegisterType((*EmptyResponse)(nil), "resource_usage_agent.EmptyResponse") proto.RegisterType((*ResourceUsageRecord)(nil), "resource_usage_agent.ResourceUsageRecord") proto.RegisterType((*GroupTagRecord)(nil), "resource_usage_agent.GroupTagRecord") proto.RegisterType((*GroupTagRecordItem)(nil), "resource_usage_agent.GroupTagRecordItem") } // 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 // Client API for ResourceUsageAgent service type ResourceUsageAgentClient interface { // Report the resource usage records. By default, the records with the same // resource group tag will be batched by minute. Report(ctx context.Context, opts ...grpc.CallOption) (ResourceUsageAgent_ReportClient, error) } type resourceUsageAgentClient struct { cc *grpc.ClientConn } func NewResourceUsageAgentClient(cc *grpc.ClientConn) ResourceUsageAgentClient { return &resourceUsageAgentClient{cc} } func (c *resourceUsageAgentClient) Report(ctx context.Context, opts ...grpc.CallOption) (ResourceUsageAgent_ReportClient, error) { stream, err := c.cc.NewStream(ctx, &_ResourceUsageAgent_serviceDesc.Streams[0], "/resource_usage_agent.ResourceUsageAgent/Report", opts...) if err != nil { return nil, err } x := &resourceUsageAgentReportClient{stream} return x, nil } type ResourceUsageAgent_ReportClient interface { Send(*ResourceUsageRecord) error CloseAndRecv() (*EmptyResponse, error) grpc.ClientStream } type resourceUsageAgentReportClient struct { grpc.ClientStream } func (x *resourceUsageAgentReportClient) Send(m *ResourceUsageRecord) error { return x.ClientStream.SendMsg(m) } func (x *resourceUsageAgentReportClient) CloseAndRecv() (*EmptyResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(EmptyResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for ResourceUsageAgent service type ResourceUsageAgentServer interface { // Report the resource usage records. By default, the records with the same // resource group tag will be batched by minute. Report(ResourceUsageAgent_ReportServer) error } func RegisterResourceUsageAgentServer(s *grpc.Server, srv ResourceUsageAgentServer) { s.RegisterService(&_ResourceUsageAgent_serviceDesc, srv) } func _ResourceUsageAgent_Report_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ResourceUsageAgentServer).Report(&resourceUsageAgentReportServer{stream}) } type ResourceUsageAgent_ReportServer interface { SendAndClose(*EmptyResponse) error Recv() (*ResourceUsageRecord, error) grpc.ServerStream } type resourceUsageAgentReportServer struct { grpc.ServerStream } func (x *resourceUsageAgentReportServer) SendAndClose(m *EmptyResponse) error { return x.ServerStream.SendMsg(m) } func (x *resourceUsageAgentReportServer) Recv() (*ResourceUsageRecord, error) { m := new(ResourceUsageRecord) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } var _ResourceUsageAgent_serviceDesc = grpc.ServiceDesc{ ServiceName: "resource_usage_agent.ResourceUsageAgent", HandlerType: (*ResourceUsageAgentServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "Report", Handler: _ResourceUsageAgent_Report_Handler, ClientStreams: true, }, }, Metadata: "resource_usage_agent.proto", } // Client API for ResourceMeteringPubSub service type ResourceMeteringPubSubClient interface { // Clients subscribe to resource metering records through this RPC, and TiKV periodically (e.g. per minute) // publishes resource metering records to clients via gRPC stream. Subscribe(ctx context.Context, in *ResourceMeteringRequest, opts ...grpc.CallOption) (ResourceMeteringPubSub_SubscribeClient, error) } type resourceMeteringPubSubClient struct { cc *grpc.ClientConn } func NewResourceMeteringPubSubClient(cc *grpc.ClientConn) ResourceMeteringPubSubClient { return &resourceMeteringPubSubClient{cc} } func (c *resourceMeteringPubSubClient) Subscribe(ctx context.Context, in *ResourceMeteringRequest, opts ...grpc.CallOption) (ResourceMeteringPubSub_SubscribeClient, error) { stream, err := c.cc.NewStream(ctx, &_ResourceMeteringPubSub_serviceDesc.Streams[0], "/resource_usage_agent.ResourceMeteringPubSub/Subscribe", opts...) if err != nil { return nil, err } x := &resourceMeteringPubSubSubscribeClient{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 ResourceMeteringPubSub_SubscribeClient interface { Recv() (*ResourceUsageRecord, error) grpc.ClientStream } type resourceMeteringPubSubSubscribeClient struct { grpc.ClientStream } func (x *resourceMeteringPubSubSubscribeClient) Recv() (*ResourceUsageRecord, error) { m := new(ResourceUsageRecord) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for ResourceMeteringPubSub service type ResourceMeteringPubSubServer interface { // Clients subscribe to resource metering records through this RPC, and TiKV periodically (e.g. per minute) // publishes resource metering records to clients via gRPC stream. Subscribe(*ResourceMeteringRequest, ResourceMeteringPubSub_SubscribeServer) error } func RegisterResourceMeteringPubSubServer(s *grpc.Server, srv ResourceMeteringPubSubServer) { s.RegisterService(&_ResourceMeteringPubSub_serviceDesc, srv) } func _ResourceMeteringPubSub_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ResourceMeteringRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(ResourceMeteringPubSubServer).Subscribe(m, &resourceMeteringPubSubSubscribeServer{stream}) } type ResourceMeteringPubSub_SubscribeServer interface { Send(*ResourceUsageRecord) error grpc.ServerStream } type resourceMeteringPubSubSubscribeServer struct { grpc.ServerStream } func (x *resourceMeteringPubSubSubscribeServer) Send(m *ResourceUsageRecord) error { return x.ServerStream.SendMsg(m) } var _ResourceMeteringPubSub_serviceDesc = grpc.ServiceDesc{ ServiceName: "resource_usage_agent.ResourceMeteringPubSub", HandlerType: (*ResourceMeteringPubSubServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "Subscribe", Handler: _ResourceMeteringPubSub_Subscribe_Handler, ServerStreams: true, }, }, Metadata: "resource_usage_agent.proto", } func (m *ResourceMeteringRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResourceMeteringRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *EmptyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *EmptyResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResourceUsageRecord) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *ResourceUsageRecord) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RecordOneof != nil { nn1, err := m.RecordOneof.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *ResourceUsageRecord_Record) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Record != nil { dAtA[i] = 0xa i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(m.Record.Size())) n2, err := m.Record.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } return i, nil } func (m *GroupTagRecord) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GroupTagRecord) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.ResourceGroupTag) > 0 { dAtA[i] = 0xa i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(len(m.ResourceGroupTag))) i += copy(dAtA[i:], m.ResourceGroupTag) } if len(m.Items) > 0 { for _, msg := range m.Items { dAtA[i] = 0x12 i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *GroupTagRecordItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *GroupTagRecordItem) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TimestampSec != 0 { dAtA[i] = 0x8 i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(m.TimestampSec)) } if m.CpuTimeMs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(m.CpuTimeMs)) } if m.ReadKeys != 0 { dAtA[i] = 0x18 i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(m.ReadKeys)) } if m.WriteKeys != 0 { dAtA[i] = 0x20 i++ i = encodeVarintResourceUsageAgent(dAtA, i, uint64(m.WriteKeys)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintResourceUsageAgent(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *ResourceMeteringRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *EmptyResponse) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResourceUsageRecord) Size() (n int) { var l int _ = l if m.RecordOneof != nil { n += m.RecordOneof.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *ResourceUsageRecord_Record) Size() (n int) { var l int _ = l if m.Record != nil { l = m.Record.Size() n += 1 + l + sovResourceUsageAgent(uint64(l)) } return n } func (m *GroupTagRecord) Size() (n int) { var l int _ = l l = len(m.ResourceGroupTag) if l > 0 { n += 1 + l + sovResourceUsageAgent(uint64(l)) } if len(m.Items) > 0 { for _, e := range m.Items { l = e.Size() n += 1 + l + sovResourceUsageAgent(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *GroupTagRecordItem) Size() (n int) { var l int _ = l if m.TimestampSec != 0 { n += 1 + sovResourceUsageAgent(uint64(m.TimestampSec)) } if m.CpuTimeMs != 0 { n += 1 + sovResourceUsageAgent(uint64(m.CpuTimeMs)) } if m.ReadKeys != 0 { n += 1 + sovResourceUsageAgent(uint64(m.ReadKeys)) } if m.WriteKeys != 0 { n += 1 + sovResourceUsageAgent(uint64(m.WriteKeys)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovResourceUsageAgent(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozResourceUsageAgent(x uint64) (n int) { return sovResourceUsageAgent(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *ResourceMeteringRequest) 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 ErrIntOverflowResourceUsageAgent } 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: ResourceMeteringRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResourceMeteringRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipResourceUsageAgent(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthResourceUsageAgent } 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 *EmptyResponse) 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 ErrIntOverflowResourceUsageAgent } 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: EmptyResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: EmptyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipResourceUsageAgent(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthResourceUsageAgent } 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 *ResourceUsageRecord) 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 ErrIntOverflowResourceUsageAgent } 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: ResourceUsageRecord: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ResourceUsageRecord: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Record", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthResourceUsageAgent } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &GroupTagRecord{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.RecordOneof = &ResourceUsageRecord_Record{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipResourceUsageAgent(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthResourceUsageAgent } 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 *GroupTagRecord) 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 ErrIntOverflowResourceUsageAgent } 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: GroupTagRecord: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GroupTagRecord: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceGroupTag", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthResourceUsageAgent } postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } m.ResourceGroupTag = append(m.ResourceGroupTag[:0], dAtA[iNdEx:postIndex]...) if m.ResourceGroupTag == nil { m.ResourceGroupTag = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthResourceUsageAgent } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Items = append(m.Items, &GroupTagRecordItem{}) if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipResourceUsageAgent(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthResourceUsageAgent } 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 *GroupTagRecordItem) 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 ErrIntOverflowResourceUsageAgent } 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: GroupTagRecordItem: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GroupTagRecordItem: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TimestampSec", wireType) } m.TimestampSec = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TimestampSec |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuTimeMs", wireType) } m.CpuTimeMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuTimeMs |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadKeys", wireType) } m.ReadKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ReadKeys |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field WriteKeys", wireType) } m.WriteKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.WriteKeys |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipResourceUsageAgent(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthResourceUsageAgent } 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 skipResourceUsageAgent(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowResourceUsageAgent } 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, ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthResourceUsageAgent } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowResourceUsageAgent } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipResourceUsageAgent(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthResourceUsageAgent = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowResourceUsageAgent = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("resource_usage_agent.proto", fileDescriptor_resource_usage_agent_8426a9d1c2864a7c) } var fileDescriptor_resource_usage_agent_8426a9d1c2864a7c = []byte{ // 432 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x4d, 0x6b, 0xd4, 0x40, 0x18, 0xde, 0xb1, 0x75, 0xe9, 0xbe, 0xbb, 0xdb, 0x96, 0xb1, 0xe8, 0x1a, 0x31, 0x94, 0x54, 0x24, 0x82, 0xae, 0x12, 0xef, 0x05, 0x0b, 0xa2, 0x22, 0x05, 0x99, 0xad, 0x37, 0x61, 0x48, 0xd2, 0xd7, 0x61, 0x58, 0x92, 0x19, 0xe7, 0xa3, 0xb2, 0x17, 0x2f, 0xfe, 0x06, 0xc1, 0x9f, 0xe0, 0x4f, 0xf1, 0xe8, 0xd1, 0xa3, 0xac, 0x7f, 0x44, 0x32, 0xe9, 0x16, 0xb6, 0x86, 0xd2, 0x53, 0x5e, 0x9e, 0x8f, 0x3c, 0xcf, 0xcc, 0xbc, 0x10, 0x19, 0xb4, 0xca, 0x9b, 0x12, 0xb9, 0xb7, 0xb9, 0x40, 0x9e, 0x0b, 0xac, 0xdd, 0x54, 0x1b, 0xe5, 0x14, 0xdd, 0xeb, 0xe2, 0xa2, 0x3d, 0xa1, 0x84, 0x0a, 0x82, 0xa7, 0xcd, 0xd4, 0x6a, 0xa3, 0x1d, 0xe3, 0xad, 0x0b, 0x63, 0x0b, 0x24, 0x77, 0xe1, 0x0e, 0x3b, 0xb7, 0x1f, 0xa3, 0x43, 0x23, 0x6b, 0xc1, 0xf0, 0x93, 0x47, 0xeb, 0x92, 0x1d, 0x18, 0xbf, 0xac, 0xb4, 0x5b, 0x30, 0xb4, 0x5a, 0xd5, 0x16, 0x13, 0x84, 0x5b, 0x2b, 0xed, 0xfb, 0x26, 0x89, 0x61, 0xa9, 0xcc, 0x29, 0x3d, 0x84, 0xbe, 0x09, 0xd3, 0x84, 0xec, 0x93, 0x74, 0x98, 0x3d, 0x98, 0x76, 0x96, 0x7d, 0x65, 0x94, 0xd7, 0x27, 0xb9, 0x68, 0x5d, 0xaf, 0x7b, 0xec, 0xdc, 0x75, 0xb4, 0x0d, 0xa3, 0x76, 0xe2, 0xaa, 0x46, 0xf5, 0x31, 0xf9, 0x02, 0xdb, 0xeb, 0x5a, 0xfa, 0x18, 0xe8, 0xc5, 0x2f, 0x45, 0x43, 0x71, 0x97, 0x8b, 0x90, 0x36, 0x62, 0xbb, 0x2b, 0x66, 0xe5, 0xa1, 0x87, 0x70, 0x53, 0x3a, 0xac, 0xec, 0xe4, 0xc6, 0xfe, 0x46, 0x3a, 0xcc, 0xd2, 0xeb, 0xd4, 0x79, 0xe3, 0xb0, 0x62, 0xad, 0x2d, 0xf9, 0x46, 0x80, 0xfe, 0xcf, 0xd2, 0x03, 0x18, 0x3b, 0x59, 0xa1, 0x75, 0x79, 0xa5, 0xb9, 0xc5, 0x32, 0xe4, 0x6f, 0xb2, 0xd1, 0x05, 0x38, 0xc3, 0x92, 0xc6, 0x30, 0x2c, 0xb5, 0xe7, 0x0d, 0xc6, 0x43, 0x03, 0x92, 0x8e, 0xd9, 0xa0, 0xd4, 0xfe, 0x44, 0x56, 0x78, 0x6c, 0xe9, 0x3d, 0x18, 0x18, 0xcc, 0x4f, 0xf9, 0x1c, 0x17, 0x76, 0xb2, 0x11, 0xd8, 0xad, 0x06, 0x78, 0x8b, 0x0b, 0x4b, 0xef, 0x03, 0x7c, 0x36, 0xd2, 0x61, 0xcb, 0x6e, 0xb6, 0xde, 0x80, 0x34, 0x74, 0x66, 0x80, 0xae, 0x5d, 0xff, 0x8b, 0xe6, 0x1c, 0xf4, 0x03, 0xf4, 0x19, 0x6a, 0x65, 0x1c, 0x7d, 0xd4, 0x7d, 0xd0, 0x8e, 0x27, 0x8b, 0x0e, 0xba, 0xa5, 0xeb, 0xcf, 0xdd, 0x4b, 0x49, 0xf6, 0x95, 0xc0, 0xed, 0xcb, 0xfb, 0xf1, 0xce, 0x17, 0x33, 0x5f, 0x50, 0x09, 0x83, 0x99, 0x2f, 0x6c, 0x69, 0x64, 0x81, 0xf4, 0xc9, 0xd5, 0xd9, 0x97, 0x56, 0x2b, 0xba, 0x7e, 0xd5, 0xa4, 0xf7, 0x8c, 0x1c, 0x3d, 0xfc, 0xfd, 0x63, 0x8b, 0xfc, 0x5c, 0xc6, 0xe4, 0xd7, 0x32, 0x26, 0x7f, 0x96, 0x31, 0xf9, 0xfe, 0x37, 0xee, 0xc1, 0xae, 0x32, 0x62, 0xea, 0xe4, 0xfc, 0x6c, 0x3a, 0x3f, 0x0b, 0xcb, 0x5c, 0xf4, 0xc3, 0xe7, 0xf9, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0xb8, 0xf4, 0x12, 0x2e, 0x03, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/sharedbytes/000077500000000000000000000000001421456440000174035ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/sharedbytes/sharedbytes.go000066400000000000000000000022771421456440000222570ustar00rootroot00000000000000// Copyright 2017 PingCAP, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. package sharedbytes // SharedBytes is a custom type for protobuf, it does not // allocates memory in Unmarshal. type SharedBytes []byte // Marshal implements custom type for gogo/protobuf. func (sb SharedBytes) Marshal() ([]byte, error) { data := make([]byte, len(sb)) copy(data, sb) return data, nil } // MarshalTo implements custom type for gogo/protobuf. func (sb SharedBytes) MarshalTo(data []byte) (n int, err error) { n = copy(data, sb) return } // Unmarshal implements custom type for gogo/protobuf. func (sb *SharedBytes) Unmarshal(data []byte) error { *sb = data return nil } // Size implements custom type for gogo/protobuf. func (sb SharedBytes) Size() int { return len(sb) } kvproto-6.1.0-alpha/pkg/sharedbytes/sharedbytes_test.go000066400000000000000000000010041421456440000233010ustar00rootroot00000000000000package sharedbytes import ( "bytes" "testing" ) func TestShardBytes(t *testing.T) { var sb SharedBytes sb = []byte("abc") x, err := sb.Marshal() if err != nil { t.Fatal(err) } if !bytes.Equal(x, []byte("abc")) { t.Fatal("marshal failed") } x = make([]byte, 3) sb.MarshalTo(x) if !bytes.Equal(x, []byte("abc")) { t.Fatal("marshal failed") } sb = nil if err := sb.Unmarshal([]byte("abc")); err != nil { t.Fatal(err) } if !bytes.Equal(sb, []byte("abc")) { t.Fatal("unmarshal failed") } } kvproto-6.1.0-alpha/pkg/span/000077500000000000000000000000001421456440000160275ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/span/span.pb.go000066400000000000000000001115641421456440000177270ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: span.proto package span import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type SpanSet struct { StartTimeNs uint64 `protobuf:"varint,1,opt,name=start_time_ns,json=startTimeNs,proto3" json:"start_time_ns,omitempty"` CyclesPerSec uint64 `protobuf:"varint,2,opt,name=cycles_per_sec,json=cyclesPerSec,proto3" json:"cycles_per_sec,omitempty"` Spans []*Span `protobuf:"bytes,3,rep,name=spans" json:"spans,omitempty"` CreateTimeNs uint64 `protobuf:"varint,4,opt,name=create_time_ns,json=createTimeNs,proto3" json:"create_time_ns,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SpanSet) Reset() { *m = SpanSet{} } func (m *SpanSet) String() string { return proto.CompactTextString(m) } func (*SpanSet) ProtoMessage() {} func (*SpanSet) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{0} } func (m *SpanSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SpanSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SpanSet.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *SpanSet) XXX_Merge(src proto.Message) { xxx_messageInfo_SpanSet.Merge(dst, src) } func (m *SpanSet) XXX_Size() int { return m.Size() } func (m *SpanSet) XXX_DiscardUnknown() { xxx_messageInfo_SpanSet.DiscardUnknown(m) } var xxx_messageInfo_SpanSet proto.InternalMessageInfo func (m *SpanSet) GetStartTimeNs() uint64 { if m != nil { return m.StartTimeNs } return 0 } func (m *SpanSet) GetCyclesPerSec() uint64 { if m != nil { return m.CyclesPerSec } return 0 } func (m *SpanSet) GetSpans() []*Span { if m != nil { return m.Spans } return nil } func (m *SpanSet) GetCreateTimeNs() uint64 { if m != nil { return m.CreateTimeNs } return 0 } type Root struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Root) Reset() { *m = Root{} } func (m *Root) String() string { return proto.CompactTextString(m) } func (*Root) ProtoMessage() {} func (*Root) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{1} } func (m *Root) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Root) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Root.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Root) XXX_Merge(src proto.Message) { xxx_messageInfo_Root.Merge(dst, src) } func (m *Root) XXX_Size() int { return m.Size() } func (m *Root) XXX_DiscardUnknown() { xxx_messageInfo_Root.DiscardUnknown(m) } var xxx_messageInfo_Root proto.InternalMessageInfo type Parent struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Parent) Reset() { *m = Parent{} } func (m *Parent) String() string { return proto.CompactTextString(m) } func (*Parent) ProtoMessage() {} func (*Parent) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{2} } func (m *Parent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Parent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Parent.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Parent) XXX_Merge(src proto.Message) { xxx_messageInfo_Parent.Merge(dst, src) } func (m *Parent) XXX_Size() int { return m.Size() } func (m *Parent) XXX_DiscardUnknown() { xxx_messageInfo_Parent.DiscardUnknown(m) } var xxx_messageInfo_Parent proto.InternalMessageInfo func (m *Parent) GetId() uint64 { if m != nil { return m.Id } return 0 } type Continue struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Continue) Reset() { *m = Continue{} } func (m *Continue) String() string { return proto.CompactTextString(m) } func (*Continue) ProtoMessage() {} func (*Continue) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{3} } func (m *Continue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Continue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Continue.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Continue) XXX_Merge(src proto.Message) { xxx_messageInfo_Continue.Merge(dst, src) } func (m *Continue) XXX_Size() int { return m.Size() } func (m *Continue) XXX_DiscardUnknown() { xxx_messageInfo_Continue.DiscardUnknown(m) } var xxx_messageInfo_Continue proto.InternalMessageInfo func (m *Continue) GetId() uint64 { if m != nil { return m.Id } return 0 } type Link struct { // Types that are valid to be assigned to Link: // *Link_Root // *Link_Parent // *Link_Continue Link isLink_Link `protobuf_oneof:"link"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Link) Reset() { *m = Link{} } func (m *Link) String() string { return proto.CompactTextString(m) } func (*Link) ProtoMessage() {} func (*Link) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{4} } func (m *Link) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Link) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Link.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Link) XXX_Merge(src proto.Message) { xxx_messageInfo_Link.Merge(dst, src) } func (m *Link) XXX_Size() int { return m.Size() } func (m *Link) XXX_DiscardUnknown() { xxx_messageInfo_Link.DiscardUnknown(m) } var xxx_messageInfo_Link proto.InternalMessageInfo type isLink_Link interface { isLink_Link() MarshalTo([]byte) (int, error) Size() int } type Link_Root struct { Root *Root `protobuf:"bytes,1,opt,name=root,oneof"` } type Link_Parent struct { Parent *Parent `protobuf:"bytes,2,opt,name=parent,oneof"` } type Link_Continue struct { Continue *Continue `protobuf:"bytes,3,opt,name=continue,oneof"` } func (*Link_Root) isLink_Link() {} func (*Link_Parent) isLink_Link() {} func (*Link_Continue) isLink_Link() {} func (m *Link) GetLink() isLink_Link { if m != nil { return m.Link } return nil } func (m *Link) GetRoot() *Root { if x, ok := m.GetLink().(*Link_Root); ok { return x.Root } return nil } func (m *Link) GetParent() *Parent { if x, ok := m.GetLink().(*Link_Parent); ok { return x.Parent } return nil } func (m *Link) GetContinue() *Continue { if x, ok := m.GetLink().(*Link_Continue); ok { return x.Continue } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*Link) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _Link_OneofMarshaler, _Link_OneofUnmarshaler, _Link_OneofSizer, []interface{}{ (*Link_Root)(nil), (*Link_Parent)(nil), (*Link_Continue)(nil), } } func _Link_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*Link) // link switch x := m.Link.(type) { case *Link_Root: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Root); err != nil { return err } case *Link_Parent: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Parent); err != nil { return err } case *Link_Continue: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Continue); err != nil { return err } case nil: default: return fmt.Errorf("Link.Link has unexpected type %T", x) } return nil } func _Link_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*Link) switch tag { case 1: // link.root if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Root) err := b.DecodeMessage(msg) m.Link = &Link_Root{msg} return true, err case 2: // link.parent if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Parent) err := b.DecodeMessage(msg) m.Link = &Link_Parent{msg} return true, err case 3: // link.continue if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Continue) err := b.DecodeMessage(msg) m.Link = &Link_Continue{msg} return true, err default: return false, nil } } func _Link_OneofSizer(msg proto.Message) (n int) { m := msg.(*Link) // link switch x := m.Link.(type) { case *Link_Root: s := proto.Size(x.Root) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Link_Parent: s := proto.Size(x.Parent) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *Link_Continue: s := proto.Size(x.Continue) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type Span struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` Link *Link `protobuf:"bytes,2,opt,name=link" json:"link,omitempty"` BeginCycles uint64 `protobuf:"varint,3,opt,name=begin_cycles,json=beginCycles,proto3" json:"begin_cycles,omitempty"` EndCycles uint64 `protobuf:"varint,4,opt,name=end_cycles,json=endCycles,proto3" json:"end_cycles,omitempty"` Event uint32 `protobuf:"varint,5,opt,name=event,proto3" json:"event,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Span) Reset() { *m = Span{} } func (m *Span) String() string { return proto.CompactTextString(m) } func (*Span) ProtoMessage() {} func (*Span) Descriptor() ([]byte, []int) { return fileDescriptor_span_65a1ec609e5ab604, []int{5} } func (m *Span) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Span) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Span.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Span) XXX_Merge(src proto.Message) { xxx_messageInfo_Span.Merge(dst, src) } func (m *Span) XXX_Size() int { return m.Size() } func (m *Span) XXX_DiscardUnknown() { xxx_messageInfo_Span.DiscardUnknown(m) } var xxx_messageInfo_Span proto.InternalMessageInfo func (m *Span) GetId() uint64 { if m != nil { return m.Id } return 0 } func (m *Span) GetLink() *Link { if m != nil { return m.Link } return nil } func (m *Span) GetBeginCycles() uint64 { if m != nil { return m.BeginCycles } return 0 } func (m *Span) GetEndCycles() uint64 { if m != nil { return m.EndCycles } return 0 } func (m *Span) GetEvent() uint32 { if m != nil { return m.Event } return 0 } func init() { proto.RegisterType((*SpanSet)(nil), "span.SpanSet") proto.RegisterType((*Root)(nil), "span.Root") proto.RegisterType((*Parent)(nil), "span.Parent") proto.RegisterType((*Continue)(nil), "span.Continue") proto.RegisterType((*Link)(nil), "span.Link") proto.RegisterType((*Span)(nil), "span.Span") } func (m *SpanSet) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *SpanSet) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.StartTimeNs != 0 { dAtA[i] = 0x8 i++ i = encodeVarintSpan(dAtA, i, uint64(m.StartTimeNs)) } if m.CyclesPerSec != 0 { dAtA[i] = 0x10 i++ i = encodeVarintSpan(dAtA, i, uint64(m.CyclesPerSec)) } if len(m.Spans) > 0 { for _, msg := range m.Spans { dAtA[i] = 0x1a i++ i = encodeVarintSpan(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.CreateTimeNs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintSpan(dAtA, i, uint64(m.CreateTimeNs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Root) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Root) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Parent) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Parent) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Id)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Continue) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Continue) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Id)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Link) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Link) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Link != nil { nn1, err := m.Link.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Link_Root) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Root != nil { dAtA[i] = 0xa i++ i = encodeVarintSpan(dAtA, i, uint64(m.Root.Size())) n2, err := m.Root.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } return i, nil } func (m *Link_Parent) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Parent != nil { dAtA[i] = 0x12 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Parent.Size())) n3, err := m.Parent.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } return i, nil } func (m *Link_Continue) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Continue != nil { dAtA[i] = 0x1a i++ i = encodeVarintSpan(dAtA, i, uint64(m.Continue.Size())) n4, err := m.Continue.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } return i, nil } func (m *Span) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Span) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Id != 0 { dAtA[i] = 0x8 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Id)) } if m.Link != nil { dAtA[i] = 0x12 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Link.Size())) n5, err := m.Link.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } if m.BeginCycles != 0 { dAtA[i] = 0x18 i++ i = encodeVarintSpan(dAtA, i, uint64(m.BeginCycles)) } if m.EndCycles != 0 { dAtA[i] = 0x20 i++ i = encodeVarintSpan(dAtA, i, uint64(m.EndCycles)) } if m.Event != 0 { dAtA[i] = 0x28 i++ i = encodeVarintSpan(dAtA, i, uint64(m.Event)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintSpan(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *SpanSet) Size() (n int) { var l int _ = l if m.StartTimeNs != 0 { n += 1 + sovSpan(uint64(m.StartTimeNs)) } if m.CyclesPerSec != 0 { n += 1 + sovSpan(uint64(m.CyclesPerSec)) } if len(m.Spans) > 0 { for _, e := range m.Spans { l = e.Size() n += 1 + l + sovSpan(uint64(l)) } } if m.CreateTimeNs != 0 { n += 1 + sovSpan(uint64(m.CreateTimeNs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Root) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Parent) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovSpan(uint64(m.Id)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Continue) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovSpan(uint64(m.Id)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Link) Size() (n int) { var l int _ = l if m.Link != nil { n += m.Link.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Link_Root) Size() (n int) { var l int _ = l if m.Root != nil { l = m.Root.Size() n += 1 + l + sovSpan(uint64(l)) } return n } func (m *Link_Parent) Size() (n int) { var l int _ = l if m.Parent != nil { l = m.Parent.Size() n += 1 + l + sovSpan(uint64(l)) } return n } func (m *Link_Continue) Size() (n int) { var l int _ = l if m.Continue != nil { l = m.Continue.Size() n += 1 + l + sovSpan(uint64(l)) } return n } func (m *Span) Size() (n int) { var l int _ = l if m.Id != 0 { n += 1 + sovSpan(uint64(m.Id)) } if m.Link != nil { l = m.Link.Size() n += 1 + l + sovSpan(uint64(l)) } if m.BeginCycles != 0 { n += 1 + sovSpan(uint64(m.BeginCycles)) } if m.EndCycles != 0 { n += 1 + sovSpan(uint64(m.EndCycles)) } if m.Event != 0 { n += 1 + sovSpan(uint64(m.Event)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovSpan(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozSpan(x uint64) (n int) { return sovSpan(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *SpanSet) 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 ErrIntOverflowSpan } 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: SpanSet: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SpanSet: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartTimeNs", wireType) } m.StartTimeNs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartTimeNs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CyclesPerSec", wireType) } m.CyclesPerSec = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CyclesPerSec |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSpan } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Spans = append(m.Spans, &Span{}) if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreateTimeNs", wireType) } m.CreateTimeNs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreateTimeNs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 *Root) 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 ErrIntOverflowSpan } 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: Root: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Root: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 *Parent) 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 ErrIntOverflowSpan } 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: Parent: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Parent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 *Continue) 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 ErrIntOverflowSpan } 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: Continue: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Continue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 *Link) 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 ErrIntOverflowSpan } 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: Link: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSpan } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Root{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Link = &Link_Root{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSpan } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Parent{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Link = &Link_Parent{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSpan } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Continue{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Link = &Link_Continue{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 *Span) 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 ErrIntOverflowSpan } 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: Span: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Span: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Id |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthSpan } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } if m.Link == nil { m.Link = &Link{} } if err := m.Link.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BeginCycles", wireType) } m.BeginCycles = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BeginCycles |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field EndCycles", wireType) } m.EndCycles = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.EndCycles |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) } m.Event = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowSpan } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Event |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipSpan(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthSpan } 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 skipSpan(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSpan } 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, ErrIntOverflowSpan } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSpan } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthSpan } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowSpan } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipSpan(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthSpan = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowSpan = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("span.proto", fileDescriptor_span_65a1ec609e5ab604) } var fileDescriptor_span_65a1ec609e5ab604 = []byte{ // 354 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x92, 0xc1, 0x4a, 0xf3, 0x40, 0x14, 0x85, 0x33, 0xed, 0x34, 0x7f, 0xff, 0x9b, 0xb6, 0xc8, 0xe0, 0x22, 0x08, 0x86, 0x18, 0x44, 0xba, 0x90, 0x2e, 0xea, 0x1b, 0xb4, 0x9b, 0x2e, 0x44, 0xca, 0xd4, 0x7d, 0x48, 0x93, 0x8b, 0x0c, 0x6d, 0x27, 0x21, 0x19, 0x05, 0x5f, 0xc0, 0xa5, 0x6b, 0xc1, 0x17, 0x72, 0xe9, 0x23, 0x48, 0x7d, 0x11, 0xc9, 0x9d, 0x69, 0x17, 0xba, 0x4b, 0xce, 0x39, 0xdc, 0xef, 0xdc, 0xcb, 0x00, 0x34, 0x55, 0xa6, 0x27, 0x55, 0x5d, 0x9a, 0x52, 0xf0, 0xf6, 0x3b, 0x79, 0x67, 0xf0, 0x6f, 0x55, 0x65, 0x7a, 0x85, 0x46, 0x24, 0x30, 0x6c, 0x4c, 0x56, 0x9b, 0xd4, 0xa8, 0x1d, 0xa6, 0xba, 0x09, 0x59, 0xcc, 0xc6, 0x5c, 0x06, 0x24, 0xde, 0xab, 0x1d, 0xde, 0x35, 0xe2, 0x12, 0x46, 0xf9, 0x73, 0xbe, 0xc5, 0x26, 0xad, 0xb0, 0x4e, 0x1b, 0xcc, 0xc3, 0x0e, 0x85, 0x06, 0x56, 0x5d, 0x62, 0xbd, 0xc2, 0x5c, 0xc4, 0xd0, 0x6b, 0xa7, 0x37, 0x61, 0x37, 0xee, 0x8e, 0x83, 0x29, 0x4c, 0x88, 0xdb, 0x72, 0xa4, 0x35, 0x68, 0x4e, 0x8d, 0x99, 0xc1, 0x23, 0x8c, 0xbb, 0x39, 0xa4, 0x5a, 0x5a, 0xe2, 0x03, 0x97, 0x65, 0x69, 0x92, 0x10, 0xfc, 0x65, 0x56, 0xa3, 0x36, 0x62, 0x04, 0x1d, 0x55, 0xb8, 0x62, 0x1d, 0x55, 0x24, 0x67, 0xd0, 0x9f, 0x97, 0xda, 0x28, 0xfd, 0x88, 0x7f, 0xbc, 0x17, 0x06, 0xfc, 0x56, 0xe9, 0x8d, 0x88, 0x81, 0xd7, 0x65, 0x69, 0xc8, 0x3a, 0xb6, 0x69, 0x07, 0x2f, 0x3c, 0x49, 0x8e, 0xb8, 0x02, 0xbf, 0x22, 0x00, 0xad, 0x13, 0x4c, 0x07, 0x36, 0x63, 0xa1, 0x0b, 0x4f, 0x3a, 0x57, 0x5c, 0x43, 0x3f, 0x77, 0xb8, 0xb0, 0x4b, 0xc9, 0x91, 0x4d, 0x1e, 0x4a, 0x2c, 0x3c, 0x79, 0x4c, 0xcc, 0x7c, 0xe0, 0x5b, 0xa5, 0x37, 0xc9, 0x2b, 0x03, 0xde, 0x2e, 0xff, 0xbb, 0xa1, 0x88, 0x6c, 0xc0, 0x41, 0x5d, 0xb1, 0xb6, 0xb2, 0x24, 0x5d, 0x5c, 0xc0, 0x60, 0x8d, 0x0f, 0x4a, 0xa7, 0xf6, 0xba, 0x84, 0xe4, 0x32, 0x20, 0x6d, 0x4e, 0x92, 0x38, 0x07, 0x40, 0x5d, 0x1c, 0x02, 0xf6, 0x88, 0xff, 0x51, 0x17, 0xce, 0x3e, 0x85, 0x1e, 0x3e, 0xb5, 0x7b, 0xf5, 0x62, 0x36, 0x1e, 0x4a, 0xfb, 0x33, 0x3b, 0xf9, 0xd8, 0x47, 0xec, 0x73, 0x1f, 0xb1, 0xaf, 0x7d, 0xc4, 0xde, 0xbe, 0x23, 0x6f, 0xed, 0xd3, 0xa3, 0xb8, 0xf9, 0x09, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x3d, 0xb9, 0x99, 0x22, 0x02, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/tikvpb/000077500000000000000000000000001421456440000163655ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/tikvpb/tikvpb.pb.go000066400000000000000000010115121421456440000206140ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: tikvpb.proto package tikvpb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" _ "github.com/gogo/protobuf/gogoproto" coprocessor "github.com/pingcap/kvproto/pkg/coprocessor" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" mpp "github.com/pingcap/kvproto/pkg/mpp" raft_serverpb "github.com/pingcap/kvproto/pkg/raft_serverpb" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type BatchCommandsRequest struct { Requests []*BatchCommandsRequest_Request `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"` RequestIds []uint64 `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds" json:"request_ids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsRequest) Reset() { *m = BatchCommandsRequest{} } func (m *BatchCommandsRequest) String() string { return proto.CompactTextString(m) } func (*BatchCommandsRequest) ProtoMessage() {} func (*BatchCommandsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{0} } func (m *BatchCommandsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsRequest.Merge(dst, src) } func (m *BatchCommandsRequest) XXX_Size() int { return m.Size() } func (m *BatchCommandsRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsRequest proto.InternalMessageInfo func (m *BatchCommandsRequest) GetRequests() []*BatchCommandsRequest_Request { if m != nil { return m.Requests } return nil } func (m *BatchCommandsRequest) GetRequestIds() []uint64 { if m != nil { return m.RequestIds } return nil } type BatchCommandsRequest_Request struct { // Types that are valid to be assigned to Cmd: // *BatchCommandsRequest_Request_Get // *BatchCommandsRequest_Request_Scan // *BatchCommandsRequest_Request_Prewrite // *BatchCommandsRequest_Request_Commit // *BatchCommandsRequest_Request_Import // *BatchCommandsRequest_Request_Cleanup // *BatchCommandsRequest_Request_BatchGet // *BatchCommandsRequest_Request_BatchRollback // *BatchCommandsRequest_Request_ScanLock // *BatchCommandsRequest_Request_ResolveLock // *BatchCommandsRequest_Request_GC // *BatchCommandsRequest_Request_DeleteRange // *BatchCommandsRequest_Request_RawGet // *BatchCommandsRequest_Request_RawBatchGet // *BatchCommandsRequest_Request_RawPut // *BatchCommandsRequest_Request_RawBatchPut // *BatchCommandsRequest_Request_RawDelete // *BatchCommandsRequest_Request_RawBatchDelete // *BatchCommandsRequest_Request_RawScan // *BatchCommandsRequest_Request_RawDeleteRange // *BatchCommandsRequest_Request_RawBatchScan // *BatchCommandsRequest_Request_Coprocessor // *BatchCommandsRequest_Request_PessimisticLock // *BatchCommandsRequest_Request_PessimisticRollback // *BatchCommandsRequest_Request_CheckTxnStatus // *BatchCommandsRequest_Request_TxnHeartBeat // *BatchCommandsRequest_Request_CheckSecondaryLocks // *BatchCommandsRequest_Request_RawCoprocessor // *BatchCommandsRequest_Request_Empty Cmd isBatchCommandsRequest_Request_Cmd `protobuf_oneof:"cmd"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsRequest_Request) Reset() { *m = BatchCommandsRequest_Request{} } func (m *BatchCommandsRequest_Request) String() string { return proto.CompactTextString(m) } func (*BatchCommandsRequest_Request) ProtoMessage() {} func (*BatchCommandsRequest_Request) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{0, 0} } func (m *BatchCommandsRequest_Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsRequest_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsRequest_Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsRequest_Request) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsRequest_Request.Merge(dst, src) } func (m *BatchCommandsRequest_Request) XXX_Size() int { return m.Size() } func (m *BatchCommandsRequest_Request) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsRequest_Request.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsRequest_Request proto.InternalMessageInfo type isBatchCommandsRequest_Request_Cmd interface { isBatchCommandsRequest_Request_Cmd() MarshalTo([]byte) (int, error) Size() int } type BatchCommandsRequest_Request_Get struct { Get *kvrpcpb.GetRequest `protobuf:"bytes,1,opt,name=Get,oneof"` } type BatchCommandsRequest_Request_Scan struct { Scan *kvrpcpb.ScanRequest `protobuf:"bytes,2,opt,name=Scan,oneof"` } type BatchCommandsRequest_Request_Prewrite struct { Prewrite *kvrpcpb.PrewriteRequest `protobuf:"bytes,3,opt,name=Prewrite,oneof"` } type BatchCommandsRequest_Request_Commit struct { Commit *kvrpcpb.CommitRequest `protobuf:"bytes,4,opt,name=Commit,oneof"` } type BatchCommandsRequest_Request_Import struct { Import *kvrpcpb.ImportRequest `protobuf:"bytes,5,opt,name=Import,oneof"` } type BatchCommandsRequest_Request_Cleanup struct { Cleanup *kvrpcpb.CleanupRequest `protobuf:"bytes,6,opt,name=Cleanup,oneof"` } type BatchCommandsRequest_Request_BatchGet struct { BatchGet *kvrpcpb.BatchGetRequest `protobuf:"bytes,7,opt,name=BatchGet,oneof"` } type BatchCommandsRequest_Request_BatchRollback struct { BatchRollback *kvrpcpb.BatchRollbackRequest `protobuf:"bytes,8,opt,name=BatchRollback,oneof"` } type BatchCommandsRequest_Request_ScanLock struct { ScanLock *kvrpcpb.ScanLockRequest `protobuf:"bytes,9,opt,name=ScanLock,oneof"` } type BatchCommandsRequest_Request_ResolveLock struct { ResolveLock *kvrpcpb.ResolveLockRequest `protobuf:"bytes,10,opt,name=ResolveLock,oneof"` } type BatchCommandsRequest_Request_GC struct { GC *kvrpcpb.GCRequest `protobuf:"bytes,11,opt,name=GC,oneof"` } type BatchCommandsRequest_Request_DeleteRange struct { DeleteRange *kvrpcpb.DeleteRangeRequest `protobuf:"bytes,12,opt,name=DeleteRange,oneof"` } type BatchCommandsRequest_Request_RawGet struct { RawGet *kvrpcpb.RawGetRequest `protobuf:"bytes,13,opt,name=RawGet,oneof"` } type BatchCommandsRequest_Request_RawBatchGet struct { RawBatchGet *kvrpcpb.RawBatchGetRequest `protobuf:"bytes,14,opt,name=RawBatchGet,oneof"` } type BatchCommandsRequest_Request_RawPut struct { RawPut *kvrpcpb.RawPutRequest `protobuf:"bytes,15,opt,name=RawPut,oneof"` } type BatchCommandsRequest_Request_RawBatchPut struct { RawBatchPut *kvrpcpb.RawBatchPutRequest `protobuf:"bytes,16,opt,name=RawBatchPut,oneof"` } type BatchCommandsRequest_Request_RawDelete struct { RawDelete *kvrpcpb.RawDeleteRequest `protobuf:"bytes,17,opt,name=RawDelete,oneof"` } type BatchCommandsRequest_Request_RawBatchDelete struct { RawBatchDelete *kvrpcpb.RawBatchDeleteRequest `protobuf:"bytes,18,opt,name=RawBatchDelete,oneof"` } type BatchCommandsRequest_Request_RawScan struct { RawScan *kvrpcpb.RawScanRequest `protobuf:"bytes,19,opt,name=RawScan,oneof"` } type BatchCommandsRequest_Request_RawDeleteRange struct { RawDeleteRange *kvrpcpb.RawDeleteRangeRequest `protobuf:"bytes,20,opt,name=RawDeleteRange,oneof"` } type BatchCommandsRequest_Request_RawBatchScan struct { RawBatchScan *kvrpcpb.RawBatchScanRequest `protobuf:"bytes,21,opt,name=RawBatchScan,oneof"` } type BatchCommandsRequest_Request_Coprocessor struct { Coprocessor *coprocessor.Request `protobuf:"bytes,22,opt,name=Coprocessor,oneof"` } type BatchCommandsRequest_Request_PessimisticLock struct { PessimisticLock *kvrpcpb.PessimisticLockRequest `protobuf:"bytes,23,opt,name=PessimisticLock,oneof"` } type BatchCommandsRequest_Request_PessimisticRollback struct { PessimisticRollback *kvrpcpb.PessimisticRollbackRequest `protobuf:"bytes,24,opt,name=PessimisticRollback,oneof"` } type BatchCommandsRequest_Request_CheckTxnStatus struct { CheckTxnStatus *kvrpcpb.CheckTxnStatusRequest `protobuf:"bytes,25,opt,name=CheckTxnStatus,oneof"` } type BatchCommandsRequest_Request_TxnHeartBeat struct { TxnHeartBeat *kvrpcpb.TxnHeartBeatRequest `protobuf:"bytes,26,opt,name=TxnHeartBeat,oneof"` } type BatchCommandsRequest_Request_CheckSecondaryLocks struct { CheckSecondaryLocks *kvrpcpb.CheckSecondaryLocksRequest `protobuf:"bytes,33,opt,name=CheckSecondaryLocks,oneof"` } type BatchCommandsRequest_Request_RawCoprocessor struct { RawCoprocessor *kvrpcpb.RawCoprocessorRequest `protobuf:"bytes,34,opt,name=RawCoprocessor,oneof"` } type BatchCommandsRequest_Request_Empty struct { Empty *BatchCommandsEmptyRequest `protobuf:"bytes,255,opt,name=Empty,oneof"` } func (*BatchCommandsRequest_Request_Get) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Scan) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Prewrite) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Commit) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Import) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Cleanup) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_BatchGet) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_BatchRollback) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_ScanLock) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_ResolveLock) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_GC) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_DeleteRange) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawGet) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawBatchGet) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawPut) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawBatchPut) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawDelete) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawBatchDelete) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawScan) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawDeleteRange) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawBatchScan) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Coprocessor) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_PessimisticLock) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_PessimisticRollback) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_CheckTxnStatus) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_TxnHeartBeat) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_CheckSecondaryLocks) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_RawCoprocessor) isBatchCommandsRequest_Request_Cmd() {} func (*BatchCommandsRequest_Request_Empty) isBatchCommandsRequest_Request_Cmd() {} func (m *BatchCommandsRequest_Request) GetCmd() isBatchCommandsRequest_Request_Cmd { if m != nil { return m.Cmd } return nil } func (m *BatchCommandsRequest_Request) GetGet() *kvrpcpb.GetRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Get); ok { return x.Get } return nil } func (m *BatchCommandsRequest_Request) GetScan() *kvrpcpb.ScanRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Scan); ok { return x.Scan } return nil } func (m *BatchCommandsRequest_Request) GetPrewrite() *kvrpcpb.PrewriteRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Prewrite); ok { return x.Prewrite } return nil } func (m *BatchCommandsRequest_Request) GetCommit() *kvrpcpb.CommitRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Commit); ok { return x.Commit } return nil } func (m *BatchCommandsRequest_Request) GetImport() *kvrpcpb.ImportRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Import); ok { return x.Import } return nil } func (m *BatchCommandsRequest_Request) GetCleanup() *kvrpcpb.CleanupRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Cleanup); ok { return x.Cleanup } return nil } func (m *BatchCommandsRequest_Request) GetBatchGet() *kvrpcpb.BatchGetRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_BatchGet); ok { return x.BatchGet } return nil } func (m *BatchCommandsRequest_Request) GetBatchRollback() *kvrpcpb.BatchRollbackRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_BatchRollback); ok { return x.BatchRollback } return nil } func (m *BatchCommandsRequest_Request) GetScanLock() *kvrpcpb.ScanLockRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_ScanLock); ok { return x.ScanLock } return nil } func (m *BatchCommandsRequest_Request) GetResolveLock() *kvrpcpb.ResolveLockRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_ResolveLock); ok { return x.ResolveLock } return nil } func (m *BatchCommandsRequest_Request) GetGC() *kvrpcpb.GCRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_GC); ok { return x.GC } return nil } func (m *BatchCommandsRequest_Request) GetDeleteRange() *kvrpcpb.DeleteRangeRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_DeleteRange); ok { return x.DeleteRange } return nil } func (m *BatchCommandsRequest_Request) GetRawGet() *kvrpcpb.RawGetRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawGet); ok { return x.RawGet } return nil } func (m *BatchCommandsRequest_Request) GetRawBatchGet() *kvrpcpb.RawBatchGetRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchGet); ok { return x.RawBatchGet } return nil } func (m *BatchCommandsRequest_Request) GetRawPut() *kvrpcpb.RawPutRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawPut); ok { return x.RawPut } return nil } func (m *BatchCommandsRequest_Request) GetRawBatchPut() *kvrpcpb.RawBatchPutRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchPut); ok { return x.RawBatchPut } return nil } func (m *BatchCommandsRequest_Request) GetRawDelete() *kvrpcpb.RawDeleteRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawDelete); ok { return x.RawDelete } return nil } func (m *BatchCommandsRequest_Request) GetRawBatchDelete() *kvrpcpb.RawBatchDeleteRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchDelete); ok { return x.RawBatchDelete } return nil } func (m *BatchCommandsRequest_Request) GetRawScan() *kvrpcpb.RawScanRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawScan); ok { return x.RawScan } return nil } func (m *BatchCommandsRequest_Request) GetRawDeleteRange() *kvrpcpb.RawDeleteRangeRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawDeleteRange); ok { return x.RawDeleteRange } return nil } func (m *BatchCommandsRequest_Request) GetRawBatchScan() *kvrpcpb.RawBatchScanRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchScan); ok { return x.RawBatchScan } return nil } func (m *BatchCommandsRequest_Request) GetCoprocessor() *coprocessor.Request { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Coprocessor); ok { return x.Coprocessor } return nil } func (m *BatchCommandsRequest_Request) GetPessimisticLock() *kvrpcpb.PessimisticLockRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_PessimisticLock); ok { return x.PessimisticLock } return nil } func (m *BatchCommandsRequest_Request) GetPessimisticRollback() *kvrpcpb.PessimisticRollbackRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_PessimisticRollback); ok { return x.PessimisticRollback } return nil } func (m *BatchCommandsRequest_Request) GetCheckTxnStatus() *kvrpcpb.CheckTxnStatusRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_CheckTxnStatus); ok { return x.CheckTxnStatus } return nil } func (m *BatchCommandsRequest_Request) GetTxnHeartBeat() *kvrpcpb.TxnHeartBeatRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_TxnHeartBeat); ok { return x.TxnHeartBeat } return nil } func (m *BatchCommandsRequest_Request) GetCheckSecondaryLocks() *kvrpcpb.CheckSecondaryLocksRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_CheckSecondaryLocks); ok { return x.CheckSecondaryLocks } return nil } func (m *BatchCommandsRequest_Request) GetRawCoprocessor() *kvrpcpb.RawCoprocessorRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawCoprocessor); ok { return x.RawCoprocessor } return nil } func (m *BatchCommandsRequest_Request) GetEmpty() *BatchCommandsEmptyRequest { if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Empty); ok { return x.Empty } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*BatchCommandsRequest_Request) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _BatchCommandsRequest_Request_OneofMarshaler, _BatchCommandsRequest_Request_OneofUnmarshaler, _BatchCommandsRequest_Request_OneofSizer, []interface{}{ (*BatchCommandsRequest_Request_Get)(nil), (*BatchCommandsRequest_Request_Scan)(nil), (*BatchCommandsRequest_Request_Prewrite)(nil), (*BatchCommandsRequest_Request_Commit)(nil), (*BatchCommandsRequest_Request_Import)(nil), (*BatchCommandsRequest_Request_Cleanup)(nil), (*BatchCommandsRequest_Request_BatchGet)(nil), (*BatchCommandsRequest_Request_BatchRollback)(nil), (*BatchCommandsRequest_Request_ScanLock)(nil), (*BatchCommandsRequest_Request_ResolveLock)(nil), (*BatchCommandsRequest_Request_GC)(nil), (*BatchCommandsRequest_Request_DeleteRange)(nil), (*BatchCommandsRequest_Request_RawGet)(nil), (*BatchCommandsRequest_Request_RawBatchGet)(nil), (*BatchCommandsRequest_Request_RawPut)(nil), (*BatchCommandsRequest_Request_RawBatchPut)(nil), (*BatchCommandsRequest_Request_RawDelete)(nil), (*BatchCommandsRequest_Request_RawBatchDelete)(nil), (*BatchCommandsRequest_Request_RawScan)(nil), (*BatchCommandsRequest_Request_RawDeleteRange)(nil), (*BatchCommandsRequest_Request_RawBatchScan)(nil), (*BatchCommandsRequest_Request_Coprocessor)(nil), (*BatchCommandsRequest_Request_PessimisticLock)(nil), (*BatchCommandsRequest_Request_PessimisticRollback)(nil), (*BatchCommandsRequest_Request_CheckTxnStatus)(nil), (*BatchCommandsRequest_Request_TxnHeartBeat)(nil), (*BatchCommandsRequest_Request_CheckSecondaryLocks)(nil), (*BatchCommandsRequest_Request_RawCoprocessor)(nil), (*BatchCommandsRequest_Request_Empty)(nil), } } func _BatchCommandsRequest_Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*BatchCommandsRequest_Request) // cmd switch x := m.Cmd.(type) { case *BatchCommandsRequest_Request_Get: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Get); err != nil { return err } case *BatchCommandsRequest_Request_Scan: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Scan); err != nil { return err } case *BatchCommandsRequest_Request_Prewrite: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Prewrite); err != nil { return err } case *BatchCommandsRequest_Request_Commit: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Commit); err != nil { return err } case *BatchCommandsRequest_Request_Import: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Import); err != nil { return err } case *BatchCommandsRequest_Request_Cleanup: _ = b.EncodeVarint(6<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Cleanup); err != nil { return err } case *BatchCommandsRequest_Request_BatchGet: _ = b.EncodeVarint(7<<3 | proto.WireBytes) if err := b.EncodeMessage(x.BatchGet); err != nil { return err } case *BatchCommandsRequest_Request_BatchRollback: _ = b.EncodeVarint(8<<3 | proto.WireBytes) if err := b.EncodeMessage(x.BatchRollback); err != nil { return err } case *BatchCommandsRequest_Request_ScanLock: _ = b.EncodeVarint(9<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ScanLock); err != nil { return err } case *BatchCommandsRequest_Request_ResolveLock: _ = b.EncodeVarint(10<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ResolveLock); err != nil { return err } case *BatchCommandsRequest_Request_GC: _ = b.EncodeVarint(11<<3 | proto.WireBytes) if err := b.EncodeMessage(x.GC); err != nil { return err } case *BatchCommandsRequest_Request_DeleteRange: _ = b.EncodeVarint(12<<3 | proto.WireBytes) if err := b.EncodeMessage(x.DeleteRange); err != nil { return err } case *BatchCommandsRequest_Request_RawGet: _ = b.EncodeVarint(13<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawGet); err != nil { return err } case *BatchCommandsRequest_Request_RawBatchGet: _ = b.EncodeVarint(14<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchGet); err != nil { return err } case *BatchCommandsRequest_Request_RawPut: _ = b.EncodeVarint(15<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawPut); err != nil { return err } case *BatchCommandsRequest_Request_RawBatchPut: _ = b.EncodeVarint(16<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchPut); err != nil { return err } case *BatchCommandsRequest_Request_RawDelete: _ = b.EncodeVarint(17<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawDelete); err != nil { return err } case *BatchCommandsRequest_Request_RawBatchDelete: _ = b.EncodeVarint(18<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchDelete); err != nil { return err } case *BatchCommandsRequest_Request_RawScan: _ = b.EncodeVarint(19<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawScan); err != nil { return err } case *BatchCommandsRequest_Request_RawDeleteRange: _ = b.EncodeVarint(20<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawDeleteRange); err != nil { return err } case *BatchCommandsRequest_Request_RawBatchScan: _ = b.EncodeVarint(21<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchScan); err != nil { return err } case *BatchCommandsRequest_Request_Coprocessor: _ = b.EncodeVarint(22<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Coprocessor); err != nil { return err } case *BatchCommandsRequest_Request_PessimisticLock: _ = b.EncodeVarint(23<<3 | proto.WireBytes) if err := b.EncodeMessage(x.PessimisticLock); err != nil { return err } case *BatchCommandsRequest_Request_PessimisticRollback: _ = b.EncodeVarint(24<<3 | proto.WireBytes) if err := b.EncodeMessage(x.PessimisticRollback); err != nil { return err } case *BatchCommandsRequest_Request_CheckTxnStatus: _ = b.EncodeVarint(25<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CheckTxnStatus); err != nil { return err } case *BatchCommandsRequest_Request_TxnHeartBeat: _ = b.EncodeVarint(26<<3 | proto.WireBytes) if err := b.EncodeMessage(x.TxnHeartBeat); err != nil { return err } case *BatchCommandsRequest_Request_CheckSecondaryLocks: _ = b.EncodeVarint(33<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CheckSecondaryLocks); err != nil { return err } case *BatchCommandsRequest_Request_RawCoprocessor: _ = b.EncodeVarint(34<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawCoprocessor); err != nil { return err } case *BatchCommandsRequest_Request_Empty: _ = b.EncodeVarint(255<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Empty); err != nil { return err } case nil: default: return fmt.Errorf("BatchCommandsRequest_Request.Cmd has unexpected type %T", x) } return nil } func _BatchCommandsRequest_Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*BatchCommandsRequest_Request) switch tag { case 1: // cmd.Get if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.GetRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Get{msg} return true, err case 2: // cmd.Scan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ScanRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Scan{msg} return true, err case 3: // cmd.Prewrite if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PrewriteRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Prewrite{msg} return true, err case 4: // cmd.Commit if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CommitRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Commit{msg} return true, err case 5: // cmd.Import if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ImportRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Import{msg} return true, err case 6: // cmd.Cleanup if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CleanupRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Cleanup{msg} return true, err case 7: // cmd.BatchGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.BatchGetRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_BatchGet{msg} return true, err case 8: // cmd.BatchRollback if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.BatchRollbackRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_BatchRollback{msg} return true, err case 9: // cmd.ScanLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ScanLockRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_ScanLock{msg} return true, err case 10: // cmd.ResolveLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ResolveLockRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_ResolveLock{msg} return true, err case 11: // cmd.GC if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.GCRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_GC{msg} return true, err case 12: // cmd.DeleteRange if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.DeleteRangeRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_DeleteRange{msg} return true, err case 13: // cmd.RawGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawGetRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawGet{msg} return true, err case 14: // cmd.RawBatchGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchGetRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawBatchGet{msg} return true, err case 15: // cmd.RawPut if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawPutRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawPut{msg} return true, err case 16: // cmd.RawBatchPut if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchPutRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawBatchPut{msg} return true, err case 17: // cmd.RawDelete if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawDeleteRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawDelete{msg} return true, err case 18: // cmd.RawBatchDelete if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchDeleteRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawBatchDelete{msg} return true, err case 19: // cmd.RawScan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawScanRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawScan{msg} return true, err case 20: // cmd.RawDeleteRange if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawDeleteRangeRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawDeleteRange{msg} return true, err case 21: // cmd.RawBatchScan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchScanRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawBatchScan{msg} return true, err case 22: // cmd.Coprocessor if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(coprocessor.Request) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Coprocessor{msg} return true, err case 23: // cmd.PessimisticLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PessimisticLockRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_PessimisticLock{msg} return true, err case 24: // cmd.PessimisticRollback if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PessimisticRollbackRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_PessimisticRollback{msg} return true, err case 25: // cmd.CheckTxnStatus if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CheckTxnStatusRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_CheckTxnStatus{msg} return true, err case 26: // cmd.TxnHeartBeat if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.TxnHeartBeatRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_TxnHeartBeat{msg} return true, err case 33: // cmd.CheckSecondaryLocks if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CheckSecondaryLocksRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_CheckSecondaryLocks{msg} return true, err case 34: // cmd.RawCoprocessor if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawCoprocessorRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_RawCoprocessor{msg} return true, err case 255: // cmd.Empty if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(BatchCommandsEmptyRequest) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsRequest_Request_Empty{msg} return true, err default: return false, nil } } func _BatchCommandsRequest_Request_OneofSizer(msg proto.Message) (n int) { m := msg.(*BatchCommandsRequest_Request) // cmd switch x := m.Cmd.(type) { case *BatchCommandsRequest_Request_Get: s := proto.Size(x.Get) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Scan: s := proto.Size(x.Scan) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Prewrite: s := proto.Size(x.Prewrite) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Commit: s := proto.Size(x.Commit) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Import: s := proto.Size(x.Import) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Cleanup: s := proto.Size(x.Cleanup) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_BatchGet: s := proto.Size(x.BatchGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_BatchRollback: s := proto.Size(x.BatchRollback) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_ScanLock: s := proto.Size(x.ScanLock) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_ResolveLock: s := proto.Size(x.ResolveLock) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_GC: s := proto.Size(x.GC) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_DeleteRange: s := proto.Size(x.DeleteRange) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawGet: s := proto.Size(x.RawGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawBatchGet: s := proto.Size(x.RawBatchGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawPut: s := proto.Size(x.RawPut) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawBatchPut: s := proto.Size(x.RawBatchPut) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawDelete: s := proto.Size(x.RawDelete) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawBatchDelete: s := proto.Size(x.RawBatchDelete) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawScan: s := proto.Size(x.RawScan) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawDeleteRange: s := proto.Size(x.RawDeleteRange) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawBatchScan: s := proto.Size(x.RawBatchScan) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Coprocessor: s := proto.Size(x.Coprocessor) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_PessimisticLock: s := proto.Size(x.PessimisticLock) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_PessimisticRollback: s := proto.Size(x.PessimisticRollback) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_CheckTxnStatus: s := proto.Size(x.CheckTxnStatus) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_TxnHeartBeat: s := proto.Size(x.TxnHeartBeat) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_CheckSecondaryLocks: s := proto.Size(x.CheckSecondaryLocks) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_RawCoprocessor: s := proto.Size(x.RawCoprocessor) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsRequest_Request_Empty: s := proto.Size(x.Empty) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type BatchCommandsResponse struct { Responses []*BatchCommandsResponse_Response `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"` RequestIds []uint64 `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds" json:"request_ids,omitempty"` // 280 means TiKV gRPC cpu usage is 280%. TransportLayerLoad uint64 `protobuf:"varint,3,opt,name=transport_layer_load,json=transportLayerLoad,proto3" json:"transport_layer_load,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsResponse) Reset() { *m = BatchCommandsResponse{} } func (m *BatchCommandsResponse) String() string { return proto.CompactTextString(m) } func (*BatchCommandsResponse) ProtoMessage() {} func (*BatchCommandsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{1} } func (m *BatchCommandsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsResponse.Merge(dst, src) } func (m *BatchCommandsResponse) XXX_Size() int { return m.Size() } func (m *BatchCommandsResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsResponse proto.InternalMessageInfo func (m *BatchCommandsResponse) GetResponses() []*BatchCommandsResponse_Response { if m != nil { return m.Responses } return nil } func (m *BatchCommandsResponse) GetRequestIds() []uint64 { if m != nil { return m.RequestIds } return nil } func (m *BatchCommandsResponse) GetTransportLayerLoad() uint64 { if m != nil { return m.TransportLayerLoad } return 0 } type BatchCommandsResponse_Response struct { // Types that are valid to be assigned to Cmd: // *BatchCommandsResponse_Response_Get // *BatchCommandsResponse_Response_Scan // *BatchCommandsResponse_Response_Prewrite // *BatchCommandsResponse_Response_Commit // *BatchCommandsResponse_Response_Import // *BatchCommandsResponse_Response_Cleanup // *BatchCommandsResponse_Response_BatchGet // *BatchCommandsResponse_Response_BatchRollback // *BatchCommandsResponse_Response_ScanLock // *BatchCommandsResponse_Response_ResolveLock // *BatchCommandsResponse_Response_GC // *BatchCommandsResponse_Response_DeleteRange // *BatchCommandsResponse_Response_RawGet // *BatchCommandsResponse_Response_RawBatchGet // *BatchCommandsResponse_Response_RawPut // *BatchCommandsResponse_Response_RawBatchPut // *BatchCommandsResponse_Response_RawDelete // *BatchCommandsResponse_Response_RawBatchDelete // *BatchCommandsResponse_Response_RawScan // *BatchCommandsResponse_Response_RawDeleteRange // *BatchCommandsResponse_Response_RawBatchScan // *BatchCommandsResponse_Response_Coprocessor // *BatchCommandsResponse_Response_PessimisticLock // *BatchCommandsResponse_Response_PessimisticRollback // *BatchCommandsResponse_Response_CheckTxnStatus // *BatchCommandsResponse_Response_TxnHeartBeat // *BatchCommandsResponse_Response_CheckSecondaryLocks // *BatchCommandsResponse_Response_RawCoprocessor // *BatchCommandsResponse_Response_Empty Cmd isBatchCommandsResponse_Response_Cmd `protobuf_oneof:"cmd"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsResponse_Response) Reset() { *m = BatchCommandsResponse_Response{} } func (m *BatchCommandsResponse_Response) String() string { return proto.CompactTextString(m) } func (*BatchCommandsResponse_Response) ProtoMessage() {} func (*BatchCommandsResponse_Response) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{1, 0} } func (m *BatchCommandsResponse_Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsResponse_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsResponse_Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsResponse_Response) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsResponse_Response.Merge(dst, src) } func (m *BatchCommandsResponse_Response) XXX_Size() int { return m.Size() } func (m *BatchCommandsResponse_Response) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsResponse_Response.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsResponse_Response proto.InternalMessageInfo type isBatchCommandsResponse_Response_Cmd interface { isBatchCommandsResponse_Response_Cmd() MarshalTo([]byte) (int, error) Size() int } type BatchCommandsResponse_Response_Get struct { Get *kvrpcpb.GetResponse `protobuf:"bytes,1,opt,name=Get,oneof"` } type BatchCommandsResponse_Response_Scan struct { Scan *kvrpcpb.ScanResponse `protobuf:"bytes,2,opt,name=Scan,oneof"` } type BatchCommandsResponse_Response_Prewrite struct { Prewrite *kvrpcpb.PrewriteResponse `protobuf:"bytes,3,opt,name=Prewrite,oneof"` } type BatchCommandsResponse_Response_Commit struct { Commit *kvrpcpb.CommitResponse `protobuf:"bytes,4,opt,name=Commit,oneof"` } type BatchCommandsResponse_Response_Import struct { Import *kvrpcpb.ImportResponse `protobuf:"bytes,5,opt,name=Import,oneof"` } type BatchCommandsResponse_Response_Cleanup struct { Cleanup *kvrpcpb.CleanupResponse `protobuf:"bytes,6,opt,name=Cleanup,oneof"` } type BatchCommandsResponse_Response_BatchGet struct { BatchGet *kvrpcpb.BatchGetResponse `protobuf:"bytes,7,opt,name=BatchGet,oneof"` } type BatchCommandsResponse_Response_BatchRollback struct { BatchRollback *kvrpcpb.BatchRollbackResponse `protobuf:"bytes,8,opt,name=BatchRollback,oneof"` } type BatchCommandsResponse_Response_ScanLock struct { ScanLock *kvrpcpb.ScanLockResponse `protobuf:"bytes,9,opt,name=ScanLock,oneof"` } type BatchCommandsResponse_Response_ResolveLock struct { ResolveLock *kvrpcpb.ResolveLockResponse `protobuf:"bytes,10,opt,name=ResolveLock,oneof"` } type BatchCommandsResponse_Response_GC struct { GC *kvrpcpb.GCResponse `protobuf:"bytes,11,opt,name=GC,oneof"` } type BatchCommandsResponse_Response_DeleteRange struct { DeleteRange *kvrpcpb.DeleteRangeResponse `protobuf:"bytes,12,opt,name=DeleteRange,oneof"` } type BatchCommandsResponse_Response_RawGet struct { RawGet *kvrpcpb.RawGetResponse `protobuf:"bytes,13,opt,name=RawGet,oneof"` } type BatchCommandsResponse_Response_RawBatchGet struct { RawBatchGet *kvrpcpb.RawBatchGetResponse `protobuf:"bytes,14,opt,name=RawBatchGet,oneof"` } type BatchCommandsResponse_Response_RawPut struct { RawPut *kvrpcpb.RawPutResponse `protobuf:"bytes,15,opt,name=RawPut,oneof"` } type BatchCommandsResponse_Response_RawBatchPut struct { RawBatchPut *kvrpcpb.RawBatchPutResponse `protobuf:"bytes,16,opt,name=RawBatchPut,oneof"` } type BatchCommandsResponse_Response_RawDelete struct { RawDelete *kvrpcpb.RawDeleteResponse `protobuf:"bytes,17,opt,name=RawDelete,oneof"` } type BatchCommandsResponse_Response_RawBatchDelete struct { RawBatchDelete *kvrpcpb.RawBatchDeleteResponse `protobuf:"bytes,18,opt,name=RawBatchDelete,oneof"` } type BatchCommandsResponse_Response_RawScan struct { RawScan *kvrpcpb.RawScanResponse `protobuf:"bytes,19,opt,name=RawScan,oneof"` } type BatchCommandsResponse_Response_RawDeleteRange struct { RawDeleteRange *kvrpcpb.RawDeleteRangeResponse `protobuf:"bytes,20,opt,name=RawDeleteRange,oneof"` } type BatchCommandsResponse_Response_RawBatchScan struct { RawBatchScan *kvrpcpb.RawBatchScanResponse `protobuf:"bytes,21,opt,name=RawBatchScan,oneof"` } type BatchCommandsResponse_Response_Coprocessor struct { Coprocessor *coprocessor.Response `protobuf:"bytes,22,opt,name=Coprocessor,oneof"` } type BatchCommandsResponse_Response_PessimisticLock struct { PessimisticLock *kvrpcpb.PessimisticLockResponse `protobuf:"bytes,23,opt,name=PessimisticLock,oneof"` } type BatchCommandsResponse_Response_PessimisticRollback struct { PessimisticRollback *kvrpcpb.PessimisticRollbackResponse `protobuf:"bytes,24,opt,name=PessimisticRollback,oneof"` } type BatchCommandsResponse_Response_CheckTxnStatus struct { CheckTxnStatus *kvrpcpb.CheckTxnStatusResponse `protobuf:"bytes,25,opt,name=CheckTxnStatus,oneof"` } type BatchCommandsResponse_Response_TxnHeartBeat struct { TxnHeartBeat *kvrpcpb.TxnHeartBeatResponse `protobuf:"bytes,26,opt,name=TxnHeartBeat,oneof"` } type BatchCommandsResponse_Response_CheckSecondaryLocks struct { CheckSecondaryLocks *kvrpcpb.CheckSecondaryLocksResponse `protobuf:"bytes,33,opt,name=CheckSecondaryLocks,oneof"` } type BatchCommandsResponse_Response_RawCoprocessor struct { RawCoprocessor *kvrpcpb.RawCoprocessorResponse `protobuf:"bytes,34,opt,name=RawCoprocessor,oneof"` } type BatchCommandsResponse_Response_Empty struct { Empty *BatchCommandsEmptyResponse `protobuf:"bytes,255,opt,name=Empty,oneof"` } func (*BatchCommandsResponse_Response_Get) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Scan) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Prewrite) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Commit) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Import) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Cleanup) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_BatchGet) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_BatchRollback) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_ScanLock) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_ResolveLock) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_GC) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_DeleteRange) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawGet) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawBatchGet) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawPut) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawBatchPut) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawDelete) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawBatchDelete) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawScan) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawDeleteRange) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawBatchScan) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Coprocessor) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_PessimisticLock) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_PessimisticRollback) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_CheckTxnStatus) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_TxnHeartBeat) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_CheckSecondaryLocks) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_RawCoprocessor) isBatchCommandsResponse_Response_Cmd() {} func (*BatchCommandsResponse_Response_Empty) isBatchCommandsResponse_Response_Cmd() {} func (m *BatchCommandsResponse_Response) GetCmd() isBatchCommandsResponse_Response_Cmd { if m != nil { return m.Cmd } return nil } func (m *BatchCommandsResponse_Response) GetGet() *kvrpcpb.GetResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Get); ok { return x.Get } return nil } func (m *BatchCommandsResponse_Response) GetScan() *kvrpcpb.ScanResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Scan); ok { return x.Scan } return nil } func (m *BatchCommandsResponse_Response) GetPrewrite() *kvrpcpb.PrewriteResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Prewrite); ok { return x.Prewrite } return nil } func (m *BatchCommandsResponse_Response) GetCommit() *kvrpcpb.CommitResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Commit); ok { return x.Commit } return nil } func (m *BatchCommandsResponse_Response) GetImport() *kvrpcpb.ImportResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Import); ok { return x.Import } return nil } func (m *BatchCommandsResponse_Response) GetCleanup() *kvrpcpb.CleanupResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Cleanup); ok { return x.Cleanup } return nil } func (m *BatchCommandsResponse_Response) GetBatchGet() *kvrpcpb.BatchGetResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_BatchGet); ok { return x.BatchGet } return nil } func (m *BatchCommandsResponse_Response) GetBatchRollback() *kvrpcpb.BatchRollbackResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_BatchRollback); ok { return x.BatchRollback } return nil } func (m *BatchCommandsResponse_Response) GetScanLock() *kvrpcpb.ScanLockResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_ScanLock); ok { return x.ScanLock } return nil } func (m *BatchCommandsResponse_Response) GetResolveLock() *kvrpcpb.ResolveLockResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_ResolveLock); ok { return x.ResolveLock } return nil } func (m *BatchCommandsResponse_Response) GetGC() *kvrpcpb.GCResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_GC); ok { return x.GC } return nil } func (m *BatchCommandsResponse_Response) GetDeleteRange() *kvrpcpb.DeleteRangeResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_DeleteRange); ok { return x.DeleteRange } return nil } func (m *BatchCommandsResponse_Response) GetRawGet() *kvrpcpb.RawGetResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawGet); ok { return x.RawGet } return nil } func (m *BatchCommandsResponse_Response) GetRawBatchGet() *kvrpcpb.RawBatchGetResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchGet); ok { return x.RawBatchGet } return nil } func (m *BatchCommandsResponse_Response) GetRawPut() *kvrpcpb.RawPutResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawPut); ok { return x.RawPut } return nil } func (m *BatchCommandsResponse_Response) GetRawBatchPut() *kvrpcpb.RawBatchPutResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchPut); ok { return x.RawBatchPut } return nil } func (m *BatchCommandsResponse_Response) GetRawDelete() *kvrpcpb.RawDeleteResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawDelete); ok { return x.RawDelete } return nil } func (m *BatchCommandsResponse_Response) GetRawBatchDelete() *kvrpcpb.RawBatchDeleteResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchDelete); ok { return x.RawBatchDelete } return nil } func (m *BatchCommandsResponse_Response) GetRawScan() *kvrpcpb.RawScanResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawScan); ok { return x.RawScan } return nil } func (m *BatchCommandsResponse_Response) GetRawDeleteRange() *kvrpcpb.RawDeleteRangeResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawDeleteRange); ok { return x.RawDeleteRange } return nil } func (m *BatchCommandsResponse_Response) GetRawBatchScan() *kvrpcpb.RawBatchScanResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchScan); ok { return x.RawBatchScan } return nil } func (m *BatchCommandsResponse_Response) GetCoprocessor() *coprocessor.Response { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Coprocessor); ok { return x.Coprocessor } return nil } func (m *BatchCommandsResponse_Response) GetPessimisticLock() *kvrpcpb.PessimisticLockResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_PessimisticLock); ok { return x.PessimisticLock } return nil } func (m *BatchCommandsResponse_Response) GetPessimisticRollback() *kvrpcpb.PessimisticRollbackResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_PessimisticRollback); ok { return x.PessimisticRollback } return nil } func (m *BatchCommandsResponse_Response) GetCheckTxnStatus() *kvrpcpb.CheckTxnStatusResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_CheckTxnStatus); ok { return x.CheckTxnStatus } return nil } func (m *BatchCommandsResponse_Response) GetTxnHeartBeat() *kvrpcpb.TxnHeartBeatResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_TxnHeartBeat); ok { return x.TxnHeartBeat } return nil } func (m *BatchCommandsResponse_Response) GetCheckSecondaryLocks() *kvrpcpb.CheckSecondaryLocksResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_CheckSecondaryLocks); ok { return x.CheckSecondaryLocks } return nil } func (m *BatchCommandsResponse_Response) GetRawCoprocessor() *kvrpcpb.RawCoprocessorResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawCoprocessor); ok { return x.RawCoprocessor } return nil } func (m *BatchCommandsResponse_Response) GetEmpty() *BatchCommandsEmptyResponse { if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Empty); ok { return x.Empty } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*BatchCommandsResponse_Response) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _BatchCommandsResponse_Response_OneofMarshaler, _BatchCommandsResponse_Response_OneofUnmarshaler, _BatchCommandsResponse_Response_OneofSizer, []interface{}{ (*BatchCommandsResponse_Response_Get)(nil), (*BatchCommandsResponse_Response_Scan)(nil), (*BatchCommandsResponse_Response_Prewrite)(nil), (*BatchCommandsResponse_Response_Commit)(nil), (*BatchCommandsResponse_Response_Import)(nil), (*BatchCommandsResponse_Response_Cleanup)(nil), (*BatchCommandsResponse_Response_BatchGet)(nil), (*BatchCommandsResponse_Response_BatchRollback)(nil), (*BatchCommandsResponse_Response_ScanLock)(nil), (*BatchCommandsResponse_Response_ResolveLock)(nil), (*BatchCommandsResponse_Response_GC)(nil), (*BatchCommandsResponse_Response_DeleteRange)(nil), (*BatchCommandsResponse_Response_RawGet)(nil), (*BatchCommandsResponse_Response_RawBatchGet)(nil), (*BatchCommandsResponse_Response_RawPut)(nil), (*BatchCommandsResponse_Response_RawBatchPut)(nil), (*BatchCommandsResponse_Response_RawDelete)(nil), (*BatchCommandsResponse_Response_RawBatchDelete)(nil), (*BatchCommandsResponse_Response_RawScan)(nil), (*BatchCommandsResponse_Response_RawDeleteRange)(nil), (*BatchCommandsResponse_Response_RawBatchScan)(nil), (*BatchCommandsResponse_Response_Coprocessor)(nil), (*BatchCommandsResponse_Response_PessimisticLock)(nil), (*BatchCommandsResponse_Response_PessimisticRollback)(nil), (*BatchCommandsResponse_Response_CheckTxnStatus)(nil), (*BatchCommandsResponse_Response_TxnHeartBeat)(nil), (*BatchCommandsResponse_Response_CheckSecondaryLocks)(nil), (*BatchCommandsResponse_Response_RawCoprocessor)(nil), (*BatchCommandsResponse_Response_Empty)(nil), } } func _BatchCommandsResponse_Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*BatchCommandsResponse_Response) // cmd switch x := m.Cmd.(type) { case *BatchCommandsResponse_Response_Get: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Get); err != nil { return err } case *BatchCommandsResponse_Response_Scan: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Scan); err != nil { return err } case *BatchCommandsResponse_Response_Prewrite: _ = b.EncodeVarint(3<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Prewrite); err != nil { return err } case *BatchCommandsResponse_Response_Commit: _ = b.EncodeVarint(4<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Commit); err != nil { return err } case *BatchCommandsResponse_Response_Import: _ = b.EncodeVarint(5<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Import); err != nil { return err } case *BatchCommandsResponse_Response_Cleanup: _ = b.EncodeVarint(6<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Cleanup); err != nil { return err } case *BatchCommandsResponse_Response_BatchGet: _ = b.EncodeVarint(7<<3 | proto.WireBytes) if err := b.EncodeMessage(x.BatchGet); err != nil { return err } case *BatchCommandsResponse_Response_BatchRollback: _ = b.EncodeVarint(8<<3 | proto.WireBytes) if err := b.EncodeMessage(x.BatchRollback); err != nil { return err } case *BatchCommandsResponse_Response_ScanLock: _ = b.EncodeVarint(9<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ScanLock); err != nil { return err } case *BatchCommandsResponse_Response_ResolveLock: _ = b.EncodeVarint(10<<3 | proto.WireBytes) if err := b.EncodeMessage(x.ResolveLock); err != nil { return err } case *BatchCommandsResponse_Response_GC: _ = b.EncodeVarint(11<<3 | proto.WireBytes) if err := b.EncodeMessage(x.GC); err != nil { return err } case *BatchCommandsResponse_Response_DeleteRange: _ = b.EncodeVarint(12<<3 | proto.WireBytes) if err := b.EncodeMessage(x.DeleteRange); err != nil { return err } case *BatchCommandsResponse_Response_RawGet: _ = b.EncodeVarint(13<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawGet); err != nil { return err } case *BatchCommandsResponse_Response_RawBatchGet: _ = b.EncodeVarint(14<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchGet); err != nil { return err } case *BatchCommandsResponse_Response_RawPut: _ = b.EncodeVarint(15<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawPut); err != nil { return err } case *BatchCommandsResponse_Response_RawBatchPut: _ = b.EncodeVarint(16<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchPut); err != nil { return err } case *BatchCommandsResponse_Response_RawDelete: _ = b.EncodeVarint(17<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawDelete); err != nil { return err } case *BatchCommandsResponse_Response_RawBatchDelete: _ = b.EncodeVarint(18<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchDelete); err != nil { return err } case *BatchCommandsResponse_Response_RawScan: _ = b.EncodeVarint(19<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawScan); err != nil { return err } case *BatchCommandsResponse_Response_RawDeleteRange: _ = b.EncodeVarint(20<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawDeleteRange); err != nil { return err } case *BatchCommandsResponse_Response_RawBatchScan: _ = b.EncodeVarint(21<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawBatchScan); err != nil { return err } case *BatchCommandsResponse_Response_Coprocessor: _ = b.EncodeVarint(22<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Coprocessor); err != nil { return err } case *BatchCommandsResponse_Response_PessimisticLock: _ = b.EncodeVarint(23<<3 | proto.WireBytes) if err := b.EncodeMessage(x.PessimisticLock); err != nil { return err } case *BatchCommandsResponse_Response_PessimisticRollback: _ = b.EncodeVarint(24<<3 | proto.WireBytes) if err := b.EncodeMessage(x.PessimisticRollback); err != nil { return err } case *BatchCommandsResponse_Response_CheckTxnStatus: _ = b.EncodeVarint(25<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CheckTxnStatus); err != nil { return err } case *BatchCommandsResponse_Response_TxnHeartBeat: _ = b.EncodeVarint(26<<3 | proto.WireBytes) if err := b.EncodeMessage(x.TxnHeartBeat); err != nil { return err } case *BatchCommandsResponse_Response_CheckSecondaryLocks: _ = b.EncodeVarint(33<<3 | proto.WireBytes) if err := b.EncodeMessage(x.CheckSecondaryLocks); err != nil { return err } case *BatchCommandsResponse_Response_RawCoprocessor: _ = b.EncodeVarint(34<<3 | proto.WireBytes) if err := b.EncodeMessage(x.RawCoprocessor); err != nil { return err } case *BatchCommandsResponse_Response_Empty: _ = b.EncodeVarint(255<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Empty); err != nil { return err } case nil: default: return fmt.Errorf("BatchCommandsResponse_Response.Cmd has unexpected type %T", x) } return nil } func _BatchCommandsResponse_Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*BatchCommandsResponse_Response) switch tag { case 1: // cmd.Get if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.GetResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Get{msg} return true, err case 2: // cmd.Scan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ScanResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Scan{msg} return true, err case 3: // cmd.Prewrite if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PrewriteResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Prewrite{msg} return true, err case 4: // cmd.Commit if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CommitResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Commit{msg} return true, err case 5: // cmd.Import if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ImportResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Import{msg} return true, err case 6: // cmd.Cleanup if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CleanupResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Cleanup{msg} return true, err case 7: // cmd.BatchGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.BatchGetResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_BatchGet{msg} return true, err case 8: // cmd.BatchRollback if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.BatchRollbackResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_BatchRollback{msg} return true, err case 9: // cmd.ScanLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ScanLockResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_ScanLock{msg} return true, err case 10: // cmd.ResolveLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.ResolveLockResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_ResolveLock{msg} return true, err case 11: // cmd.GC if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.GCResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_GC{msg} return true, err case 12: // cmd.DeleteRange if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.DeleteRangeResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_DeleteRange{msg} return true, err case 13: // cmd.RawGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawGetResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawGet{msg} return true, err case 14: // cmd.RawBatchGet if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchGetResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawBatchGet{msg} return true, err case 15: // cmd.RawPut if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawPutResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawPut{msg} return true, err case 16: // cmd.RawBatchPut if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchPutResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawBatchPut{msg} return true, err case 17: // cmd.RawDelete if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawDeleteResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawDelete{msg} return true, err case 18: // cmd.RawBatchDelete if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchDeleteResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawBatchDelete{msg} return true, err case 19: // cmd.RawScan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawScanResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawScan{msg} return true, err case 20: // cmd.RawDeleteRange if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawDeleteRangeResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawDeleteRange{msg} return true, err case 21: // cmd.RawBatchScan if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawBatchScanResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawBatchScan{msg} return true, err case 22: // cmd.Coprocessor if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(coprocessor.Response) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Coprocessor{msg} return true, err case 23: // cmd.PessimisticLock if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PessimisticLockResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_PessimisticLock{msg} return true, err case 24: // cmd.PessimisticRollback if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.PessimisticRollbackResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_PessimisticRollback{msg} return true, err case 25: // cmd.CheckTxnStatus if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CheckTxnStatusResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_CheckTxnStatus{msg} return true, err case 26: // cmd.TxnHeartBeat if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.TxnHeartBeatResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_TxnHeartBeat{msg} return true, err case 33: // cmd.CheckSecondaryLocks if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.CheckSecondaryLocksResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_CheckSecondaryLocks{msg} return true, err case 34: // cmd.RawCoprocessor if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(kvrpcpb.RawCoprocessorResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_RawCoprocessor{msg} return true, err case 255: // cmd.Empty if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(BatchCommandsEmptyResponse) err := b.DecodeMessage(msg) m.Cmd = &BatchCommandsResponse_Response_Empty{msg} return true, err default: return false, nil } } func _BatchCommandsResponse_Response_OneofSizer(msg proto.Message) (n int) { m := msg.(*BatchCommandsResponse_Response) // cmd switch x := m.Cmd.(type) { case *BatchCommandsResponse_Response_Get: s := proto.Size(x.Get) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Scan: s := proto.Size(x.Scan) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Prewrite: s := proto.Size(x.Prewrite) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Commit: s := proto.Size(x.Commit) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Import: s := proto.Size(x.Import) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Cleanup: s := proto.Size(x.Cleanup) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_BatchGet: s := proto.Size(x.BatchGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_BatchRollback: s := proto.Size(x.BatchRollback) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_ScanLock: s := proto.Size(x.ScanLock) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_ResolveLock: s := proto.Size(x.ResolveLock) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_GC: s := proto.Size(x.GC) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_DeleteRange: s := proto.Size(x.DeleteRange) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawGet: s := proto.Size(x.RawGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawBatchGet: s := proto.Size(x.RawBatchGet) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawPut: s := proto.Size(x.RawPut) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawBatchPut: s := proto.Size(x.RawBatchPut) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawDelete: s := proto.Size(x.RawDelete) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawBatchDelete: s := proto.Size(x.RawBatchDelete) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawScan: s := proto.Size(x.RawScan) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawDeleteRange: s := proto.Size(x.RawDeleteRange) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawBatchScan: s := proto.Size(x.RawBatchScan) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Coprocessor: s := proto.Size(x.Coprocessor) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_PessimisticLock: s := proto.Size(x.PessimisticLock) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_PessimisticRollback: s := proto.Size(x.PessimisticRollback) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_CheckTxnStatus: s := proto.Size(x.CheckTxnStatus) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_TxnHeartBeat: s := proto.Size(x.TxnHeartBeat) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_CheckSecondaryLocks: s := proto.Size(x.CheckSecondaryLocks) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_RawCoprocessor: s := proto.Size(x.RawCoprocessor) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *BatchCommandsResponse_Response_Empty: s := proto.Size(x.Empty) n += 2 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type BatchRaftMessage struct { Msgs []*raft_serverpb.RaftMessage `protobuf:"bytes,1,rep,name=msgs" json:"msgs,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchRaftMessage) Reset() { *m = BatchRaftMessage{} } func (m *BatchRaftMessage) String() string { return proto.CompactTextString(m) } func (*BatchRaftMessage) ProtoMessage() {} func (*BatchRaftMessage) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{2} } func (m *BatchRaftMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchRaftMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchRaftMessage.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchRaftMessage) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchRaftMessage.Merge(dst, src) } func (m *BatchRaftMessage) XXX_Size() int { return m.Size() } func (m *BatchRaftMessage) XXX_DiscardUnknown() { xxx_messageInfo_BatchRaftMessage.DiscardUnknown(m) } var xxx_messageInfo_BatchRaftMessage proto.InternalMessageInfo func (m *BatchRaftMessage) GetMsgs() []*raft_serverpb.RaftMessage { if m != nil { return m.Msgs } return nil } type BatchCommandsEmptyRequest struct { // ID of the test request. TestId uint64 `protobuf:"varint,1,opt,name=test_id,json=testId,proto3" json:"test_id,omitempty"` // TiKV needs to delay at least such a time to response the client. DelayTime uint64 `protobuf:"varint,2,opt,name=delay_time,json=delayTime,proto3" json:"delay_time,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsEmptyRequest) Reset() { *m = BatchCommandsEmptyRequest{} } func (m *BatchCommandsEmptyRequest) String() string { return proto.CompactTextString(m) } func (*BatchCommandsEmptyRequest) ProtoMessage() {} func (*BatchCommandsEmptyRequest) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{3} } func (m *BatchCommandsEmptyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsEmptyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsEmptyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsEmptyRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsEmptyRequest.Merge(dst, src) } func (m *BatchCommandsEmptyRequest) XXX_Size() int { return m.Size() } func (m *BatchCommandsEmptyRequest) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsEmptyRequest.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsEmptyRequest proto.InternalMessageInfo func (m *BatchCommandsEmptyRequest) GetTestId() uint64 { if m != nil { return m.TestId } return 0 } func (m *BatchCommandsEmptyRequest) GetDelayTime() uint64 { if m != nil { return m.DelayTime } return 0 } type BatchCommandsEmptyResponse struct { // ID of the test request. TestId uint64 `protobuf:"varint,1,opt,name=test_id,json=testId,proto3" json:"test_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *BatchCommandsEmptyResponse) Reset() { *m = BatchCommandsEmptyResponse{} } func (m *BatchCommandsEmptyResponse) String() string { return proto.CompactTextString(m) } func (*BatchCommandsEmptyResponse) ProtoMessage() {} func (*BatchCommandsEmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptor_tikvpb_92b152ac586f1929, []int{4} } func (m *BatchCommandsEmptyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *BatchCommandsEmptyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_BatchCommandsEmptyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *BatchCommandsEmptyResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_BatchCommandsEmptyResponse.Merge(dst, src) } func (m *BatchCommandsEmptyResponse) XXX_Size() int { return m.Size() } func (m *BatchCommandsEmptyResponse) XXX_DiscardUnknown() { xxx_messageInfo_BatchCommandsEmptyResponse.DiscardUnknown(m) } var xxx_messageInfo_BatchCommandsEmptyResponse proto.InternalMessageInfo func (m *BatchCommandsEmptyResponse) GetTestId() uint64 { if m != nil { return m.TestId } return 0 } func init() { proto.RegisterType((*BatchCommandsRequest)(nil), "tikvpb.BatchCommandsRequest") proto.RegisterType((*BatchCommandsRequest_Request)(nil), "tikvpb.BatchCommandsRequest.Request") proto.RegisterType((*BatchCommandsResponse)(nil), "tikvpb.BatchCommandsResponse") proto.RegisterType((*BatchCommandsResponse_Response)(nil), "tikvpb.BatchCommandsResponse.Response") proto.RegisterType((*BatchRaftMessage)(nil), "tikvpb.BatchRaftMessage") proto.RegisterType((*BatchCommandsEmptyRequest)(nil), "tikvpb.BatchCommandsEmptyRequest") proto.RegisterType((*BatchCommandsEmptyResponse)(nil), "tikvpb.BatchCommandsEmptyResponse") } // 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 // Client API for Tikv service type TikvClient interface { // Commands using a transactional interface. KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ...grpc.CallOption) (*kvrpcpb.GetResponse, error) KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanResponse, error) KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest, opts ...grpc.CallOption) (*kvrpcpb.PrewriteResponse, error) KvPessimisticLock(ctx context.Context, in *kvrpcpb.PessimisticLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticLockResponse, error) KVPessimisticRollback(ctx context.Context, in *kvrpcpb.PessimisticRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticRollbackResponse, error) KvTxnHeartBeat(ctx context.Context, in *kvrpcpb.TxnHeartBeatRequest, opts ...grpc.CallOption) (*kvrpcpb.TxnHeartBeatResponse, error) KvCheckTxnStatus(ctx context.Context, in *kvrpcpb.CheckTxnStatusRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckTxnStatusResponse, error) KvCheckSecondaryLocks(ctx context.Context, in *kvrpcpb.CheckSecondaryLocksRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckSecondaryLocksResponse, error) KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, opts ...grpc.CallOption) (*kvrpcpb.CommitResponse, error) KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, opts ...grpc.CallOption) (*kvrpcpb.ImportResponse, error) KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, opts ...grpc.CallOption) (*kvrpcpb.CleanupResponse, error) KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchGetResponse, error) KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchRollbackResponse, error) KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanLockResponse, error) KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ResolveLockResponse, error) KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...grpc.CallOption) (*kvrpcpb.GCResponse, error) KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error) // Raw commands; no transaction support. RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error) // Get TTL of the key. Returns 0 if TTL is not set for the key. RawGetKeyTTL(ctx context.Context, in *kvrpcpb.RawGetKeyTTLRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetKeyTTLResponse, error) // Compare if the value in database equals to `RawCASRequest.previous_value` before putting the new value. If not, this request will have no effect and the value in the database will be returned. RawCompareAndSwap(ctx context.Context, in *kvrpcpb.RawCASRequest, opts ...grpc.CallOption) (*kvrpcpb.RawCASResponse, error) RawChecksum(ctx context.Context, in *kvrpcpb.RawChecksumRequest, opts ...grpc.CallOption) (*kvrpcpb.RawChecksumResponse, error) // Store commands (sent to a each TiKV node in a cluster, rather than a certain region). UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeDestroyRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.UnsafeDestroyRangeResponse, error) RegisterLockObserver(ctx context.Context, in *kvrpcpb.RegisterLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RegisterLockObserverResponse, error) CheckLockObserver(ctx context.Context, in *kvrpcpb.CheckLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLockObserverResponse, error) RemoveLockObserver(ctx context.Context, in *kvrpcpb.RemoveLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RemoveLockObserverResponse, error) PhysicalScanLock(ctx context.Context, in *kvrpcpb.PhysicalScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PhysicalScanLockResponse, error) // Commands for executing SQL in the TiKV coprocessor (i.e., 'pushed down' to TiKV rather than // executed in TiDB). Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error) BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error) // Command for executing custom user requests in TiKV coprocessor_v2. RawCoprocessor(ctx context.Context, in *kvrpcpb.RawCoprocessorRequest, opts ...grpc.CallOption) (*kvrpcpb.RawCoprocessorResponse, error) // Raft commands (sent between TiKV nodes). Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error) Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error) // Sent from PD or TiDB to a TiKV node. SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionRequest, opts ...grpc.CallOption) (*kvrpcpb.SplitRegionResponse, error) // Sent from TiFlash or TiKV to a TiKV node. ReadIndex(ctx context.Context, in *kvrpcpb.ReadIndexRequest, opts ...grpc.CallOption) (*kvrpcpb.ReadIndexResponse, error) // Commands for debugging transactions. MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByKeyResponse, error) MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetByStartTsRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByStartTsResponse, error) // Batched commands. BatchCommands(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchCommandsClient, error) // These are for mpp execution. DispatchMPPTask(ctx context.Context, in *mpp.DispatchTaskRequest, opts ...grpc.CallOption) (*mpp.DispatchTaskResponse, error) CancelMPPTask(ctx context.Context, in *mpp.CancelTaskRequest, opts ...grpc.CallOption) (*mpp.CancelTaskResponse, error) EstablishMPPConnection(ctx context.Context, in *mpp.EstablishMPPConnectionRequest, opts ...grpc.CallOption) (Tikv_EstablishMPPConnectionClient, error) IsAlive(ctx context.Context, in *mpp.IsAliveRequest, opts ...grpc.CallOption) (*mpp.IsAliveResponse, error) // / CheckLeader sends all information (includes region term and epoch) to other stores. // / Once a store receives a request, it checks term and epoch for each region, and sends the regions whose // / term and epoch match with local information in the store. // / After the client collected all responses from all stores, it checks if got a quorum of responses from // / other stores for every region, and decides to advance resolved ts from these regions. CheckLeader(ctx context.Context, in *kvrpcpb.CheckLeaderRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLeaderResponse, error) // / Get the minimal `safe_ts` from regions at the store GetStoreSafeTS(ctx context.Context, in *kvrpcpb.StoreSafeTSRequest, opts ...grpc.CallOption) (*kvrpcpb.StoreSafeTSResponse, error) // / Get the information about lock waiting from TiKV. GetLockWaitInfo(ctx context.Context, in *kvrpcpb.GetLockWaitInfoRequest, opts ...grpc.CallOption) (*kvrpcpb.GetLockWaitInfoResponse, error) } type tikvClient struct { cc *grpc.ClientConn } func NewTikvClient(cc *grpc.ClientConn) TikvClient { return &tikvClient{cc} } func (c *tikvClient) KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ...grpc.CallOption) (*kvrpcpb.GetResponse, error) { out := new(kvrpcpb.GetResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGet", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanResponse, error) { out := new(kvrpcpb.ScanResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScan", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest, opts ...grpc.CallOption) (*kvrpcpb.PrewriteResponse, error) { out := new(kvrpcpb.PrewriteResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvPrewrite", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvPessimisticLock(ctx context.Context, in *kvrpcpb.PessimisticLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticLockResponse, error) { out := new(kvrpcpb.PessimisticLockResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvPessimisticLock", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KVPessimisticRollback(ctx context.Context, in *kvrpcpb.PessimisticRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticRollbackResponse, error) { out := new(kvrpcpb.PessimisticRollbackResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KVPessimisticRollback", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvTxnHeartBeat(ctx context.Context, in *kvrpcpb.TxnHeartBeatRequest, opts ...grpc.CallOption) (*kvrpcpb.TxnHeartBeatResponse, error) { out := new(kvrpcpb.TxnHeartBeatResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvTxnHeartBeat", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvCheckTxnStatus(ctx context.Context, in *kvrpcpb.CheckTxnStatusRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckTxnStatusResponse, error) { out := new(kvrpcpb.CheckTxnStatusResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCheckTxnStatus", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvCheckSecondaryLocks(ctx context.Context, in *kvrpcpb.CheckSecondaryLocksRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckSecondaryLocksResponse, error) { out := new(kvrpcpb.CheckSecondaryLocksResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCheckSecondaryLocks", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, opts ...grpc.CallOption) (*kvrpcpb.CommitResponse, error) { out := new(kvrpcpb.CommitResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCommit", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, opts ...grpc.CallOption) (*kvrpcpb.ImportResponse, error) { out := new(kvrpcpb.ImportResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvImport", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, opts ...grpc.CallOption) (*kvrpcpb.CleanupResponse, error) { out := new(kvrpcpb.CleanupResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCleanup", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchGetResponse, error) { out := new(kvrpcpb.BatchGetResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchGet", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchRollbackResponse, error) { out := new(kvrpcpb.BatchRollbackResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchRollback", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanLockResponse, error) { out := new(kvrpcpb.ScanLockResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScanLock", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ResolveLockResponse, error) { out := new(kvrpcpb.ResolveLockResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvResolveLock", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...grpc.CallOption) (*kvrpcpb.GCResponse, error) { out := new(kvrpcpb.GCResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGC", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error) { out := new(kvrpcpb.DeleteRangeResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvDeleteRange", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error) { out := new(kvrpcpb.RawGetResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawGet", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error) { out := new(kvrpcpb.RawBatchGetResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchGet", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error) { out := new(kvrpcpb.RawPutResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawPut", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error) { out := new(kvrpcpb.RawBatchPutResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchPut", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error) { out := new(kvrpcpb.RawDeleteResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDelete", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error) { out := new(kvrpcpb.RawBatchDeleteResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchDelete", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error) { out := new(kvrpcpb.RawScanResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawScan", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error) { out := new(kvrpcpb.RawDeleteRangeResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDeleteRange", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error) { out := new(kvrpcpb.RawBatchScanResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchScan", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawGetKeyTTL(ctx context.Context, in *kvrpcpb.RawGetKeyTTLRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetKeyTTLResponse, error) { out := new(kvrpcpb.RawGetKeyTTLResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawGetKeyTTL", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawCompareAndSwap(ctx context.Context, in *kvrpcpb.RawCASRequest, opts ...grpc.CallOption) (*kvrpcpb.RawCASResponse, error) { out := new(kvrpcpb.RawCASResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawCompareAndSwap", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RawChecksum(ctx context.Context, in *kvrpcpb.RawChecksumRequest, opts ...grpc.CallOption) (*kvrpcpb.RawChecksumResponse, error) { out := new(kvrpcpb.RawChecksumResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawChecksum", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeDestroyRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.UnsafeDestroyRangeResponse, error) { out := new(kvrpcpb.UnsafeDestroyRangeResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/UnsafeDestroyRange", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RegisterLockObserver(ctx context.Context, in *kvrpcpb.RegisterLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RegisterLockObserverResponse, error) { out := new(kvrpcpb.RegisterLockObserverResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RegisterLockObserver", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) CheckLockObserver(ctx context.Context, in *kvrpcpb.CheckLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLockObserverResponse, error) { out := new(kvrpcpb.CheckLockObserverResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/CheckLockObserver", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) RemoveLockObserver(ctx context.Context, in *kvrpcpb.RemoveLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RemoveLockObserverResponse, error) { out := new(kvrpcpb.RemoveLockObserverResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RemoveLockObserver", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) PhysicalScanLock(ctx context.Context, in *kvrpcpb.PhysicalScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PhysicalScanLockResponse, error) { out := new(kvrpcpb.PhysicalScanLockResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/PhysicalScanLock", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) { out := new(coprocessor.Response) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/Coprocessor", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[0], "/tikvpb.Tikv/CoprocessorStream", opts...) if err != nil { return nil, err } x := &tikvCoprocessorStreamClient{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 Tikv_CoprocessorStreamClient interface { Recv() (*coprocessor.Response, error) grpc.ClientStream } type tikvCoprocessorStreamClient struct { grpc.ClientStream } func (x *tikvCoprocessorStreamClient) Recv() (*coprocessor.Response, error) { m := new(coprocessor.Response) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[1], "/tikvpb.Tikv/BatchCoprocessor", opts...) if err != nil { return nil, err } x := &tikvBatchCoprocessorClient{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 Tikv_BatchCoprocessorClient interface { Recv() (*coprocessor.BatchResponse, error) grpc.ClientStream } type tikvBatchCoprocessorClient struct { grpc.ClientStream } func (x *tikvBatchCoprocessorClient) Recv() (*coprocessor.BatchResponse, error) { m := new(coprocessor.BatchResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) RawCoprocessor(ctx context.Context, in *kvrpcpb.RawCoprocessorRequest, opts ...grpc.CallOption) (*kvrpcpb.RawCoprocessorResponse, error) { out := new(kvrpcpb.RawCoprocessorResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawCoprocessor", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[2], "/tikvpb.Tikv/Raft", opts...) if err != nil { return nil, err } x := &tikvRaftClient{stream} return x, nil } type Tikv_RaftClient interface { Send(*raft_serverpb.RaftMessage) error CloseAndRecv() (*raft_serverpb.Done, error) grpc.ClientStream } type tikvRaftClient struct { grpc.ClientStream } func (x *tikvRaftClient) Send(m *raft_serverpb.RaftMessage) error { return x.ClientStream.SendMsg(m) } func (x *tikvRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(raft_serverpb.Done) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[3], "/tikvpb.Tikv/BatchRaft", opts...) if err != nil { return nil, err } x := &tikvBatchRaftClient{stream} return x, nil } type Tikv_BatchRaftClient interface { Send(*BatchRaftMessage) error CloseAndRecv() (*raft_serverpb.Done, error) grpc.ClientStream } type tikvBatchRaftClient struct { grpc.ClientStream } func (x *tikvBatchRaftClient) Send(m *BatchRaftMessage) error { return x.ClientStream.SendMsg(m) } func (x *tikvBatchRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(raft_serverpb.Done) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[4], "/tikvpb.Tikv/Snapshot", opts...) if err != nil { return nil, err } x := &tikvSnapshotClient{stream} return x, nil } type Tikv_SnapshotClient interface { Send(*raft_serverpb.SnapshotChunk) error CloseAndRecv() (*raft_serverpb.Done, error) grpc.ClientStream } type tikvSnapshotClient struct { grpc.ClientStream } func (x *tikvSnapshotClient) Send(m *raft_serverpb.SnapshotChunk) error { return x.ClientStream.SendMsg(m) } func (x *tikvSnapshotClient) CloseAndRecv() (*raft_serverpb.Done, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(raft_serverpb.Done) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionRequest, opts ...grpc.CallOption) (*kvrpcpb.SplitRegionResponse, error) { out := new(kvrpcpb.SplitRegionResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/SplitRegion", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) ReadIndex(ctx context.Context, in *kvrpcpb.ReadIndexRequest, opts ...grpc.CallOption) (*kvrpcpb.ReadIndexResponse, error) { out := new(kvrpcpb.ReadIndexResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/ReadIndex", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByKeyResponse, error) { out := new(kvrpcpb.MvccGetByKeyResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByKey", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetByStartTsRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByStartTsResponse, error) { out := new(kvrpcpb.MvccGetByStartTsResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByStartTs", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) BatchCommands(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchCommandsClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[5], "/tikvpb.Tikv/BatchCommands", opts...) if err != nil { return nil, err } x := &tikvBatchCommandsClient{stream} return x, nil } type Tikv_BatchCommandsClient interface { Send(*BatchCommandsRequest) error Recv() (*BatchCommandsResponse, error) grpc.ClientStream } type tikvBatchCommandsClient struct { grpc.ClientStream } func (x *tikvBatchCommandsClient) Send(m *BatchCommandsRequest) error { return x.ClientStream.SendMsg(m) } func (x *tikvBatchCommandsClient) Recv() (*BatchCommandsResponse, error) { m := new(BatchCommandsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) DispatchMPPTask(ctx context.Context, in *mpp.DispatchTaskRequest, opts ...grpc.CallOption) (*mpp.DispatchTaskResponse, error) { out := new(mpp.DispatchTaskResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/DispatchMPPTask", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) CancelMPPTask(ctx context.Context, in *mpp.CancelTaskRequest, opts ...grpc.CallOption) (*mpp.CancelTaskResponse, error) { out := new(mpp.CancelTaskResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/CancelMPPTask", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) EstablishMPPConnection(ctx context.Context, in *mpp.EstablishMPPConnectionRequest, opts ...grpc.CallOption) (Tikv_EstablishMPPConnectionClient, error) { stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[6], "/tikvpb.Tikv/EstablishMPPConnection", opts...) if err != nil { return nil, err } x := &tikvEstablishMPPConnectionClient{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 Tikv_EstablishMPPConnectionClient interface { Recv() (*mpp.MPPDataPacket, error) grpc.ClientStream } type tikvEstablishMPPConnectionClient struct { grpc.ClientStream } func (x *tikvEstablishMPPConnectionClient) Recv() (*mpp.MPPDataPacket, error) { m := new(mpp.MPPDataPacket) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *tikvClient) IsAlive(ctx context.Context, in *mpp.IsAliveRequest, opts ...grpc.CallOption) (*mpp.IsAliveResponse, error) { out := new(mpp.IsAliveResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/IsAlive", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) CheckLeader(ctx context.Context, in *kvrpcpb.CheckLeaderRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLeaderResponse, error) { out := new(kvrpcpb.CheckLeaderResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/CheckLeader", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) GetStoreSafeTS(ctx context.Context, in *kvrpcpb.StoreSafeTSRequest, opts ...grpc.CallOption) (*kvrpcpb.StoreSafeTSResponse, error) { out := new(kvrpcpb.StoreSafeTSResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/GetStoreSafeTS", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *tikvClient) GetLockWaitInfo(ctx context.Context, in *kvrpcpb.GetLockWaitInfoRequest, opts ...grpc.CallOption) (*kvrpcpb.GetLockWaitInfoResponse, error) { out := new(kvrpcpb.GetLockWaitInfoResponse) err := c.cc.Invoke(ctx, "/tikvpb.Tikv/GetLockWaitInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } // Server API for Tikv service type TikvServer interface { // Commands using a transactional interface. KvGet(context.Context, *kvrpcpb.GetRequest) (*kvrpcpb.GetResponse, error) KvScan(context.Context, *kvrpcpb.ScanRequest) (*kvrpcpb.ScanResponse, error) KvPrewrite(context.Context, *kvrpcpb.PrewriteRequest) (*kvrpcpb.PrewriteResponse, error) KvPessimisticLock(context.Context, *kvrpcpb.PessimisticLockRequest) (*kvrpcpb.PessimisticLockResponse, error) KVPessimisticRollback(context.Context, *kvrpcpb.PessimisticRollbackRequest) (*kvrpcpb.PessimisticRollbackResponse, error) KvTxnHeartBeat(context.Context, *kvrpcpb.TxnHeartBeatRequest) (*kvrpcpb.TxnHeartBeatResponse, error) KvCheckTxnStatus(context.Context, *kvrpcpb.CheckTxnStatusRequest) (*kvrpcpb.CheckTxnStatusResponse, error) KvCheckSecondaryLocks(context.Context, *kvrpcpb.CheckSecondaryLocksRequest) (*kvrpcpb.CheckSecondaryLocksResponse, error) KvCommit(context.Context, *kvrpcpb.CommitRequest) (*kvrpcpb.CommitResponse, error) KvImport(context.Context, *kvrpcpb.ImportRequest) (*kvrpcpb.ImportResponse, error) KvCleanup(context.Context, *kvrpcpb.CleanupRequest) (*kvrpcpb.CleanupResponse, error) KvBatchGet(context.Context, *kvrpcpb.BatchGetRequest) (*kvrpcpb.BatchGetResponse, error) KvBatchRollback(context.Context, *kvrpcpb.BatchRollbackRequest) (*kvrpcpb.BatchRollbackResponse, error) KvScanLock(context.Context, *kvrpcpb.ScanLockRequest) (*kvrpcpb.ScanLockResponse, error) KvResolveLock(context.Context, *kvrpcpb.ResolveLockRequest) (*kvrpcpb.ResolveLockResponse, error) KvGC(context.Context, *kvrpcpb.GCRequest) (*kvrpcpb.GCResponse, error) KvDeleteRange(context.Context, *kvrpcpb.DeleteRangeRequest) (*kvrpcpb.DeleteRangeResponse, error) // Raw commands; no transaction support. RawGet(context.Context, *kvrpcpb.RawGetRequest) (*kvrpcpb.RawGetResponse, error) RawBatchGet(context.Context, *kvrpcpb.RawBatchGetRequest) (*kvrpcpb.RawBatchGetResponse, error) RawPut(context.Context, *kvrpcpb.RawPutRequest) (*kvrpcpb.RawPutResponse, error) RawBatchPut(context.Context, *kvrpcpb.RawBatchPutRequest) (*kvrpcpb.RawBatchPutResponse, error) RawDelete(context.Context, *kvrpcpb.RawDeleteRequest) (*kvrpcpb.RawDeleteResponse, error) RawBatchDelete(context.Context, *kvrpcpb.RawBatchDeleteRequest) (*kvrpcpb.RawBatchDeleteResponse, error) RawScan(context.Context, *kvrpcpb.RawScanRequest) (*kvrpcpb.RawScanResponse, error) RawDeleteRange(context.Context, *kvrpcpb.RawDeleteRangeRequest) (*kvrpcpb.RawDeleteRangeResponse, error) RawBatchScan(context.Context, *kvrpcpb.RawBatchScanRequest) (*kvrpcpb.RawBatchScanResponse, error) // Get TTL of the key. Returns 0 if TTL is not set for the key. RawGetKeyTTL(context.Context, *kvrpcpb.RawGetKeyTTLRequest) (*kvrpcpb.RawGetKeyTTLResponse, error) // Compare if the value in database equals to `RawCASRequest.previous_value` before putting the new value. If not, this request will have no effect and the value in the database will be returned. RawCompareAndSwap(context.Context, *kvrpcpb.RawCASRequest) (*kvrpcpb.RawCASResponse, error) RawChecksum(context.Context, *kvrpcpb.RawChecksumRequest) (*kvrpcpb.RawChecksumResponse, error) // Store commands (sent to a each TiKV node in a cluster, rather than a certain region). UnsafeDestroyRange(context.Context, *kvrpcpb.UnsafeDestroyRangeRequest) (*kvrpcpb.UnsafeDestroyRangeResponse, error) RegisterLockObserver(context.Context, *kvrpcpb.RegisterLockObserverRequest) (*kvrpcpb.RegisterLockObserverResponse, error) CheckLockObserver(context.Context, *kvrpcpb.CheckLockObserverRequest) (*kvrpcpb.CheckLockObserverResponse, error) RemoveLockObserver(context.Context, *kvrpcpb.RemoveLockObserverRequest) (*kvrpcpb.RemoveLockObserverResponse, error) PhysicalScanLock(context.Context, *kvrpcpb.PhysicalScanLockRequest) (*kvrpcpb.PhysicalScanLockResponse, error) // Commands for executing SQL in the TiKV coprocessor (i.e., 'pushed down' to TiKV rather than // executed in TiDB). Coprocessor(context.Context, *coprocessor.Request) (*coprocessor.Response, error) CoprocessorStream(*coprocessor.Request, Tikv_CoprocessorStreamServer) error BatchCoprocessor(*coprocessor.BatchRequest, Tikv_BatchCoprocessorServer) error // Command for executing custom user requests in TiKV coprocessor_v2. RawCoprocessor(context.Context, *kvrpcpb.RawCoprocessorRequest) (*kvrpcpb.RawCoprocessorResponse, error) // Raft commands (sent between TiKV nodes). Raft(Tikv_RaftServer) error BatchRaft(Tikv_BatchRaftServer) error Snapshot(Tikv_SnapshotServer) error // Sent from PD or TiDB to a TiKV node. SplitRegion(context.Context, *kvrpcpb.SplitRegionRequest) (*kvrpcpb.SplitRegionResponse, error) // Sent from TiFlash or TiKV to a TiKV node. ReadIndex(context.Context, *kvrpcpb.ReadIndexRequest) (*kvrpcpb.ReadIndexResponse, error) // Commands for debugging transactions. MvccGetByKey(context.Context, *kvrpcpb.MvccGetByKeyRequest) (*kvrpcpb.MvccGetByKeyResponse, error) MvccGetByStartTs(context.Context, *kvrpcpb.MvccGetByStartTsRequest) (*kvrpcpb.MvccGetByStartTsResponse, error) // Batched commands. BatchCommands(Tikv_BatchCommandsServer) error // These are for mpp execution. DispatchMPPTask(context.Context, *mpp.DispatchTaskRequest) (*mpp.DispatchTaskResponse, error) CancelMPPTask(context.Context, *mpp.CancelTaskRequest) (*mpp.CancelTaskResponse, error) EstablishMPPConnection(*mpp.EstablishMPPConnectionRequest, Tikv_EstablishMPPConnectionServer) error IsAlive(context.Context, *mpp.IsAliveRequest) (*mpp.IsAliveResponse, error) // / CheckLeader sends all information (includes region term and epoch) to other stores. // / Once a store receives a request, it checks term and epoch for each region, and sends the regions whose // / term and epoch match with local information in the store. // / After the client collected all responses from all stores, it checks if got a quorum of responses from // / other stores for every region, and decides to advance resolved ts from these regions. CheckLeader(context.Context, *kvrpcpb.CheckLeaderRequest) (*kvrpcpb.CheckLeaderResponse, error) // / Get the minimal `safe_ts` from regions at the store GetStoreSafeTS(context.Context, *kvrpcpb.StoreSafeTSRequest) (*kvrpcpb.StoreSafeTSResponse, error) // / Get the information about lock waiting from TiKV. GetLockWaitInfo(context.Context, *kvrpcpb.GetLockWaitInfoRequest) (*kvrpcpb.GetLockWaitInfoResponse, error) } func RegisterTikvServer(s *grpc.Server, srv TikvServer) { s.RegisterService(&_Tikv_serviceDesc, srv) } func _Tikv_KvGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.GetRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvGet(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvGet", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvGet(ctx, req.(*kvrpcpb.GetRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.ScanRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvScan(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvScan", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvScan(ctx, req.(*kvrpcpb.ScanRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvPrewrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.PrewriteRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvPrewrite(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvPrewrite", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvPrewrite(ctx, req.(*kvrpcpb.PrewriteRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvPessimisticLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.PessimisticLockRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvPessimisticLock(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvPessimisticLock", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvPessimisticLock(ctx, req.(*kvrpcpb.PessimisticLockRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KVPessimisticRollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.PessimisticRollbackRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KVPessimisticRollback(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KVPessimisticRollback", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KVPessimisticRollback(ctx, req.(*kvrpcpb.PessimisticRollbackRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvTxnHeartBeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.TxnHeartBeatRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvTxnHeartBeat(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvTxnHeartBeat", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvTxnHeartBeat(ctx, req.(*kvrpcpb.TxnHeartBeatRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvCheckTxnStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CheckTxnStatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvCheckTxnStatus(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvCheckTxnStatus", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvCheckTxnStatus(ctx, req.(*kvrpcpb.CheckTxnStatusRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvCheckSecondaryLocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CheckSecondaryLocksRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvCheckSecondaryLocks(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvCheckSecondaryLocks", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvCheckSecondaryLocks(ctx, req.(*kvrpcpb.CheckSecondaryLocksRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CommitRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvCommit(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvCommit", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvCommit(ctx, req.(*kvrpcpb.CommitRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.ImportRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvImport(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvImport", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvImport(ctx, req.(*kvrpcpb.ImportRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvCleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CleanupRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvCleanup(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvCleanup", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvCleanup(ctx, req.(*kvrpcpb.CleanupRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvBatchGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.BatchGetRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvBatchGet(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvBatchGet", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvBatchGet(ctx, req.(*kvrpcpb.BatchGetRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvBatchRollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.BatchRollbackRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvBatchRollback(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvBatchRollback", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvBatchRollback(ctx, req.(*kvrpcpb.BatchRollbackRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvScanLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.ScanLockRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvScanLock(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvScanLock", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvScanLock(ctx, req.(*kvrpcpb.ScanLockRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvResolveLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.ResolveLockRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvResolveLock(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvResolveLock", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvResolveLock(ctx, req.(*kvrpcpb.ResolveLockRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvGC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.GCRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvGC(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvGC", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvGC(ctx, req.(*kvrpcpb.GCRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_KvDeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.DeleteRangeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).KvDeleteRange(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/KvDeleteRange", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).KvDeleteRange(ctx, req.(*kvrpcpb.DeleteRangeRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawGetRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawGet(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawGet", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawGet(ctx, req.(*kvrpcpb.RawGetRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawBatchGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawBatchGetRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawBatchGet(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawBatchGet", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawBatchGet(ctx, req.(*kvrpcpb.RawBatchGetRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawPutRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawPut(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawPut", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawPut(ctx, req.(*kvrpcpb.RawPutRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawBatchPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawBatchPutRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawBatchPut(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawBatchPut", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawBatchPut(ctx, req.(*kvrpcpb.RawBatchPutRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawDeleteRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawDelete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawDelete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawDelete(ctx, req.(*kvrpcpb.RawDeleteRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawBatchDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawBatchDeleteRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawBatchDelete(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawBatchDelete", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawBatchDelete(ctx, req.(*kvrpcpb.RawBatchDeleteRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawScanRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawScan(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawScan", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawScan(ctx, req.(*kvrpcpb.RawScanRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawDeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawDeleteRangeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawDeleteRange(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawDeleteRange", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawDeleteRange(ctx, req.(*kvrpcpb.RawDeleteRangeRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawBatchScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawBatchScanRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawBatchScan(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawBatchScan", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawBatchScan(ctx, req.(*kvrpcpb.RawBatchScanRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawGetKeyTTL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawGetKeyTTLRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawGetKeyTTL(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawGetKeyTTL", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawGetKeyTTL(ctx, req.(*kvrpcpb.RawGetKeyTTLRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawCompareAndSwap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawCASRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawCompareAndSwap(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawCompareAndSwap", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawCompareAndSwap(ctx, req.(*kvrpcpb.RawCASRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RawChecksum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawChecksumRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawChecksum(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawChecksum", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawChecksum(ctx, req.(*kvrpcpb.RawChecksumRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_UnsafeDestroyRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.UnsafeDestroyRangeRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).UnsafeDestroyRange(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/UnsafeDestroyRange", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).UnsafeDestroyRange(ctx, req.(*kvrpcpb.UnsafeDestroyRangeRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RegisterLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RegisterLockObserverRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RegisterLockObserver(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RegisterLockObserver", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RegisterLockObserver(ctx, req.(*kvrpcpb.RegisterLockObserverRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_CheckLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CheckLockObserverRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).CheckLockObserver(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/CheckLockObserver", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).CheckLockObserver(ctx, req.(*kvrpcpb.CheckLockObserverRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_RemoveLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RemoveLockObserverRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RemoveLockObserver(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RemoveLockObserver", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RemoveLockObserver(ctx, req.(*kvrpcpb.RemoveLockObserverRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_PhysicalScanLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.PhysicalScanLockRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).PhysicalScanLock(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/PhysicalScanLock", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).PhysicalScanLock(ctx, req.(*kvrpcpb.PhysicalScanLockRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_Coprocessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(coprocessor.Request) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).Coprocessor(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/Coprocessor", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).Coprocessor(ctx, req.(*coprocessor.Request)) } return interceptor(ctx, in, info, handler) } func _Tikv_CoprocessorStream_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(coprocessor.Request) if err := stream.RecvMsg(m); err != nil { return err } return srv.(TikvServer).CoprocessorStream(m, &tikvCoprocessorStreamServer{stream}) } type Tikv_CoprocessorStreamServer interface { Send(*coprocessor.Response) error grpc.ServerStream } type tikvCoprocessorStreamServer struct { grpc.ServerStream } func (x *tikvCoprocessorStreamServer) Send(m *coprocessor.Response) error { return x.ServerStream.SendMsg(m) } func _Tikv_BatchCoprocessor_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(coprocessor.BatchRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(TikvServer).BatchCoprocessor(m, &tikvBatchCoprocessorServer{stream}) } type Tikv_BatchCoprocessorServer interface { Send(*coprocessor.BatchResponse) error grpc.ServerStream } type tikvBatchCoprocessorServer struct { grpc.ServerStream } func (x *tikvBatchCoprocessorServer) Send(m *coprocessor.BatchResponse) error { return x.ServerStream.SendMsg(m) } func _Tikv_RawCoprocessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.RawCoprocessorRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).RawCoprocessor(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/RawCoprocessor", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).RawCoprocessor(ctx, req.(*kvrpcpb.RawCoprocessorRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_Raft_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TikvServer).Raft(&tikvRaftServer{stream}) } type Tikv_RaftServer interface { SendAndClose(*raft_serverpb.Done) error Recv() (*raft_serverpb.RaftMessage, error) grpc.ServerStream } type tikvRaftServer struct { grpc.ServerStream } func (x *tikvRaftServer) SendAndClose(m *raft_serverpb.Done) error { return x.ServerStream.SendMsg(m) } func (x *tikvRaftServer) Recv() (*raft_serverpb.RaftMessage, error) { m := new(raft_serverpb.RaftMessage) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Tikv_BatchRaft_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TikvServer).BatchRaft(&tikvBatchRaftServer{stream}) } type Tikv_BatchRaftServer interface { SendAndClose(*raft_serverpb.Done) error Recv() (*BatchRaftMessage, error) grpc.ServerStream } type tikvBatchRaftServer struct { grpc.ServerStream } func (x *tikvBatchRaftServer) SendAndClose(m *raft_serverpb.Done) error { return x.ServerStream.SendMsg(m) } func (x *tikvBatchRaftServer) Recv() (*BatchRaftMessage, error) { m := new(BatchRaftMessage) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Tikv_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TikvServer).Snapshot(&tikvSnapshotServer{stream}) } type Tikv_SnapshotServer interface { SendAndClose(*raft_serverpb.Done) error Recv() (*raft_serverpb.SnapshotChunk, error) grpc.ServerStream } type tikvSnapshotServer struct { grpc.ServerStream } func (x *tikvSnapshotServer) SendAndClose(m *raft_serverpb.Done) error { return x.ServerStream.SendMsg(m) } func (x *tikvSnapshotServer) Recv() (*raft_serverpb.SnapshotChunk, error) { m := new(raft_serverpb.SnapshotChunk) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Tikv_SplitRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.SplitRegionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).SplitRegion(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/SplitRegion", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).SplitRegion(ctx, req.(*kvrpcpb.SplitRegionRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_ReadIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.ReadIndexRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).ReadIndex(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/ReadIndex", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).ReadIndex(ctx, req.(*kvrpcpb.ReadIndexRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_MvccGetByKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.MvccGetByKeyRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).MvccGetByKey(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/MvccGetByKey", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).MvccGetByKey(ctx, req.(*kvrpcpb.MvccGetByKeyRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_MvccGetByStartTs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.MvccGetByStartTsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).MvccGetByStartTs(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/MvccGetByStartTs", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).MvccGetByStartTs(ctx, req.(*kvrpcpb.MvccGetByStartTsRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_BatchCommands_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TikvServer).BatchCommands(&tikvBatchCommandsServer{stream}) } type Tikv_BatchCommandsServer interface { Send(*BatchCommandsResponse) error Recv() (*BatchCommandsRequest, error) grpc.ServerStream } type tikvBatchCommandsServer struct { grpc.ServerStream } func (x *tikvBatchCommandsServer) Send(m *BatchCommandsResponse) error { return x.ServerStream.SendMsg(m) } func (x *tikvBatchCommandsServer) Recv() (*BatchCommandsRequest, error) { m := new(BatchCommandsRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Tikv_DispatchMPPTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(mpp.DispatchTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).DispatchMPPTask(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/DispatchMPPTask", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).DispatchMPPTask(ctx, req.(*mpp.DispatchTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_CancelMPPTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(mpp.CancelTaskRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).CancelMPPTask(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/CancelMPPTask", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).CancelMPPTask(ctx, req.(*mpp.CancelTaskRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_EstablishMPPConnection_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(mpp.EstablishMPPConnectionRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(TikvServer).EstablishMPPConnection(m, &tikvEstablishMPPConnectionServer{stream}) } type Tikv_EstablishMPPConnectionServer interface { Send(*mpp.MPPDataPacket) error grpc.ServerStream } type tikvEstablishMPPConnectionServer struct { grpc.ServerStream } func (x *tikvEstablishMPPConnectionServer) Send(m *mpp.MPPDataPacket) error { return x.ServerStream.SendMsg(m) } func _Tikv_IsAlive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(mpp.IsAliveRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).IsAlive(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/IsAlive", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).IsAlive(ctx, req.(*mpp.IsAliveRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_CheckLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.CheckLeaderRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).CheckLeader(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/CheckLeader", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).CheckLeader(ctx, req.(*kvrpcpb.CheckLeaderRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_GetStoreSafeTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.StoreSafeTSRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).GetStoreSafeTS(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/GetStoreSafeTS", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).GetStoreSafeTS(ctx, req.(*kvrpcpb.StoreSafeTSRequest)) } return interceptor(ctx, in, info, handler) } func _Tikv_GetLockWaitInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(kvrpcpb.GetLockWaitInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(TikvServer).GetLockWaitInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/tikvpb.Tikv/GetLockWaitInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TikvServer).GetLockWaitInfo(ctx, req.(*kvrpcpb.GetLockWaitInfoRequest)) } return interceptor(ctx, in, info, handler) } var _Tikv_serviceDesc = grpc.ServiceDesc{ ServiceName: "tikvpb.Tikv", HandlerType: (*TikvServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "KvGet", Handler: _Tikv_KvGet_Handler, }, { MethodName: "KvScan", Handler: _Tikv_KvScan_Handler, }, { MethodName: "KvPrewrite", Handler: _Tikv_KvPrewrite_Handler, }, { MethodName: "KvPessimisticLock", Handler: _Tikv_KvPessimisticLock_Handler, }, { MethodName: "KVPessimisticRollback", Handler: _Tikv_KVPessimisticRollback_Handler, }, { MethodName: "KvTxnHeartBeat", Handler: _Tikv_KvTxnHeartBeat_Handler, }, { MethodName: "KvCheckTxnStatus", Handler: _Tikv_KvCheckTxnStatus_Handler, }, { MethodName: "KvCheckSecondaryLocks", Handler: _Tikv_KvCheckSecondaryLocks_Handler, }, { MethodName: "KvCommit", Handler: _Tikv_KvCommit_Handler, }, { MethodName: "KvImport", Handler: _Tikv_KvImport_Handler, }, { MethodName: "KvCleanup", Handler: _Tikv_KvCleanup_Handler, }, { MethodName: "KvBatchGet", Handler: _Tikv_KvBatchGet_Handler, }, { MethodName: "KvBatchRollback", Handler: _Tikv_KvBatchRollback_Handler, }, { MethodName: "KvScanLock", Handler: _Tikv_KvScanLock_Handler, }, { MethodName: "KvResolveLock", Handler: _Tikv_KvResolveLock_Handler, }, { MethodName: "KvGC", Handler: _Tikv_KvGC_Handler, }, { MethodName: "KvDeleteRange", Handler: _Tikv_KvDeleteRange_Handler, }, { MethodName: "RawGet", Handler: _Tikv_RawGet_Handler, }, { MethodName: "RawBatchGet", Handler: _Tikv_RawBatchGet_Handler, }, { MethodName: "RawPut", Handler: _Tikv_RawPut_Handler, }, { MethodName: "RawBatchPut", Handler: _Tikv_RawBatchPut_Handler, }, { MethodName: "RawDelete", Handler: _Tikv_RawDelete_Handler, }, { MethodName: "RawBatchDelete", Handler: _Tikv_RawBatchDelete_Handler, }, { MethodName: "RawScan", Handler: _Tikv_RawScan_Handler, }, { MethodName: "RawDeleteRange", Handler: _Tikv_RawDeleteRange_Handler, }, { MethodName: "RawBatchScan", Handler: _Tikv_RawBatchScan_Handler, }, { MethodName: "RawGetKeyTTL", Handler: _Tikv_RawGetKeyTTL_Handler, }, { MethodName: "RawCompareAndSwap", Handler: _Tikv_RawCompareAndSwap_Handler, }, { MethodName: "RawChecksum", Handler: _Tikv_RawChecksum_Handler, }, { MethodName: "UnsafeDestroyRange", Handler: _Tikv_UnsafeDestroyRange_Handler, }, { MethodName: "RegisterLockObserver", Handler: _Tikv_RegisterLockObserver_Handler, }, { MethodName: "CheckLockObserver", Handler: _Tikv_CheckLockObserver_Handler, }, { MethodName: "RemoveLockObserver", Handler: _Tikv_RemoveLockObserver_Handler, }, { MethodName: "PhysicalScanLock", Handler: _Tikv_PhysicalScanLock_Handler, }, { MethodName: "Coprocessor", Handler: _Tikv_Coprocessor_Handler, }, { MethodName: "RawCoprocessor", Handler: _Tikv_RawCoprocessor_Handler, }, { MethodName: "SplitRegion", Handler: _Tikv_SplitRegion_Handler, }, { MethodName: "ReadIndex", Handler: _Tikv_ReadIndex_Handler, }, { MethodName: "MvccGetByKey", Handler: _Tikv_MvccGetByKey_Handler, }, { MethodName: "MvccGetByStartTs", Handler: _Tikv_MvccGetByStartTs_Handler, }, { MethodName: "DispatchMPPTask", Handler: _Tikv_DispatchMPPTask_Handler, }, { MethodName: "CancelMPPTask", Handler: _Tikv_CancelMPPTask_Handler, }, { MethodName: "IsAlive", Handler: _Tikv_IsAlive_Handler, }, { MethodName: "CheckLeader", Handler: _Tikv_CheckLeader_Handler, }, { MethodName: "GetStoreSafeTS", Handler: _Tikv_GetStoreSafeTS_Handler, }, { MethodName: "GetLockWaitInfo", Handler: _Tikv_GetLockWaitInfo_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "CoprocessorStream", Handler: _Tikv_CoprocessorStream_Handler, ServerStreams: true, }, { StreamName: "BatchCoprocessor", Handler: _Tikv_BatchCoprocessor_Handler, ServerStreams: true, }, { StreamName: "Raft", Handler: _Tikv_Raft_Handler, ClientStreams: true, }, { StreamName: "BatchRaft", Handler: _Tikv_BatchRaft_Handler, ClientStreams: true, }, { StreamName: "Snapshot", Handler: _Tikv_Snapshot_Handler, ClientStreams: true, }, { StreamName: "BatchCommands", Handler: _Tikv_BatchCommands_Handler, ServerStreams: true, ClientStreams: true, }, { StreamName: "EstablishMPPConnection", Handler: _Tikv_EstablishMPPConnection_Handler, ServerStreams: true, }, }, Metadata: "tikvpb.proto", } func (m *BatchCommandsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Requests) > 0 { for _, msg := range m.Requests { dAtA[i] = 0xa i++ i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.RequestIds) > 0 { dAtA2 := make([]byte, len(m.RequestIds)*10) var j1 int for _, num := range m.RequestIds { for num >= 1<<7 { dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j1++ } dAtA2[j1] = uint8(num) j1++ } dAtA[i] = 0x12 i++ i = encodeVarintTikvpb(dAtA, i, uint64(j1)) i += copy(dAtA[i:], dAtA2[:j1]) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsRequest_Request) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsRequest_Request) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Cmd != nil { nn3, err := m.Cmd.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn3 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsRequest_Request_Get) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Get != nil { dAtA[i] = 0xa i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Get.Size())) n4, err := m.Get.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n4 } return i, nil } func (m *BatchCommandsRequest_Request_Scan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Scan != nil { dAtA[i] = 0x12 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Scan.Size())) n5, err := m.Scan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n5 } return i, nil } func (m *BatchCommandsRequest_Request_Prewrite) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Prewrite != nil { dAtA[i] = 0x1a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Prewrite.Size())) n6, err := m.Prewrite.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n6 } return i, nil } func (m *BatchCommandsRequest_Request_Commit) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Commit != nil { dAtA[i] = 0x22 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Commit.Size())) n7, err := m.Commit.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n7 } return i, nil } func (m *BatchCommandsRequest_Request_Import) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Import != nil { dAtA[i] = 0x2a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Import.Size())) n8, err := m.Import.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n8 } return i, nil } func (m *BatchCommandsRequest_Request_Cleanup) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Cleanup != nil { dAtA[i] = 0x32 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Cleanup.Size())) n9, err := m.Cleanup.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n9 } return i, nil } func (m *BatchCommandsRequest_Request_BatchGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.BatchGet != nil { dAtA[i] = 0x3a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchGet.Size())) n10, err := m.BatchGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n10 } return i, nil } func (m *BatchCommandsRequest_Request_BatchRollback) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.BatchRollback != nil { dAtA[i] = 0x42 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchRollback.Size())) n11, err := m.BatchRollback.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n11 } return i, nil } func (m *BatchCommandsRequest_Request_ScanLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ScanLock != nil { dAtA[i] = 0x4a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.ScanLock.Size())) n12, err := m.ScanLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n12 } return i, nil } func (m *BatchCommandsRequest_Request_ResolveLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ResolveLock != nil { dAtA[i] = 0x52 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.ResolveLock.Size())) n13, err := m.ResolveLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } return i, nil } func (m *BatchCommandsRequest_Request_GC) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.GC != nil { dAtA[i] = 0x5a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.GC.Size())) n14, err := m.GC.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } return i, nil } func (m *BatchCommandsRequest_Request_DeleteRange) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.DeleteRange != nil { dAtA[i] = 0x62 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.DeleteRange.Size())) n15, err := m.DeleteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n15 } return i, nil } func (m *BatchCommandsRequest_Request_RawGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawGet != nil { dAtA[i] = 0x6a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawGet.Size())) n16, err := m.RawGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n16 } return i, nil } func (m *BatchCommandsRequest_Request_RawBatchGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchGet != nil { dAtA[i] = 0x72 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchGet.Size())) n17, err := m.RawBatchGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n17 } return i, nil } func (m *BatchCommandsRequest_Request_RawPut) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawPut != nil { dAtA[i] = 0x7a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawPut.Size())) n18, err := m.RawPut.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n18 } return i, nil } func (m *BatchCommandsRequest_Request_RawBatchPut) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchPut != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchPut.Size())) n19, err := m.RawBatchPut.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n19 } return i, nil } func (m *BatchCommandsRequest_Request_RawDelete) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawDelete != nil { dAtA[i] = 0x8a i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDelete.Size())) n20, err := m.RawDelete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 } return i, nil } func (m *BatchCommandsRequest_Request_RawBatchDelete) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchDelete != nil { dAtA[i] = 0x92 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchDelete.Size())) n21, err := m.RawBatchDelete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n21 } return i, nil } func (m *BatchCommandsRequest_Request_RawScan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawScan != nil { dAtA[i] = 0x9a i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawScan.Size())) n22, err := m.RawScan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 } return i, nil } func (m *BatchCommandsRequest_Request_RawDeleteRange) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawDeleteRange != nil { dAtA[i] = 0xa2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDeleteRange.Size())) n23, err := m.RawDeleteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 } return i, nil } func (m *BatchCommandsRequest_Request_RawBatchScan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchScan != nil { dAtA[i] = 0xaa i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchScan.Size())) n24, err := m.RawBatchScan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n24 } return i, nil } func (m *BatchCommandsRequest_Request_Coprocessor) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Coprocessor != nil { dAtA[i] = 0xb2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Coprocessor.Size())) n25, err := m.Coprocessor.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } return i, nil } func (m *BatchCommandsRequest_Request_PessimisticLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.PessimisticLock != nil { dAtA[i] = 0xba i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticLock.Size())) n26, err := m.PessimisticLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } return i, nil } func (m *BatchCommandsRequest_Request_PessimisticRollback) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.PessimisticRollback != nil { dAtA[i] = 0xc2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticRollback.Size())) n27, err := m.PessimisticRollback.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n27 } return i, nil } func (m *BatchCommandsRequest_Request_CheckTxnStatus) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CheckTxnStatus != nil { dAtA[i] = 0xca i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckTxnStatus.Size())) n28, err := m.CheckTxnStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n28 } return i, nil } func (m *BatchCommandsRequest_Request_TxnHeartBeat) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.TxnHeartBeat != nil { dAtA[i] = 0xd2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.TxnHeartBeat.Size())) n29, err := m.TxnHeartBeat.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n29 } return i, nil } func (m *BatchCommandsRequest_Request_CheckSecondaryLocks) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CheckSecondaryLocks != nil { dAtA[i] = 0x8a i++ dAtA[i] = 0x2 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckSecondaryLocks.Size())) n30, err := m.CheckSecondaryLocks.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n30 } return i, nil } func (m *BatchCommandsRequest_Request_RawCoprocessor) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawCoprocessor != nil { dAtA[i] = 0x92 i++ dAtA[i] = 0x2 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawCoprocessor.Size())) n31, err := m.RawCoprocessor.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n31 } return i, nil } func (m *BatchCommandsRequest_Request_Empty) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Empty != nil { dAtA[i] = 0xfa i++ dAtA[i] = 0xf i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Empty.Size())) n32, err := m.Empty.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n32 } return i, nil } func (m *BatchCommandsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Responses) > 0 { for _, msg := range m.Responses { dAtA[i] = 0xa i++ i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.RequestIds) > 0 { dAtA34 := make([]byte, len(m.RequestIds)*10) var j33 int for _, num := range m.RequestIds { for num >= 1<<7 { dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j33++ } dAtA34[j33] = uint8(num) j33++ } dAtA[i] = 0x12 i++ i = encodeVarintTikvpb(dAtA, i, uint64(j33)) i += copy(dAtA[i:], dAtA34[:j33]) } if m.TransportLayerLoad != 0 { dAtA[i] = 0x18 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.TransportLayerLoad)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsResponse_Response) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsResponse_Response) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.Cmd != nil { nn35, err := m.Cmd.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn35 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsResponse_Response_Get) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Get != nil { dAtA[i] = 0xa i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Get.Size())) n36, err := m.Get.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n36 } return i, nil } func (m *BatchCommandsResponse_Response_Scan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Scan != nil { dAtA[i] = 0x12 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Scan.Size())) n37, err := m.Scan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n37 } return i, nil } func (m *BatchCommandsResponse_Response_Prewrite) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Prewrite != nil { dAtA[i] = 0x1a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Prewrite.Size())) n38, err := m.Prewrite.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n38 } return i, nil } func (m *BatchCommandsResponse_Response_Commit) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Commit != nil { dAtA[i] = 0x22 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Commit.Size())) n39, err := m.Commit.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n39 } return i, nil } func (m *BatchCommandsResponse_Response_Import) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Import != nil { dAtA[i] = 0x2a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Import.Size())) n40, err := m.Import.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n40 } return i, nil } func (m *BatchCommandsResponse_Response_Cleanup) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Cleanup != nil { dAtA[i] = 0x32 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Cleanup.Size())) n41, err := m.Cleanup.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n41 } return i, nil } func (m *BatchCommandsResponse_Response_BatchGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.BatchGet != nil { dAtA[i] = 0x3a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchGet.Size())) n42, err := m.BatchGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n42 } return i, nil } func (m *BatchCommandsResponse_Response_BatchRollback) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.BatchRollback != nil { dAtA[i] = 0x42 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchRollback.Size())) n43, err := m.BatchRollback.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n43 } return i, nil } func (m *BatchCommandsResponse_Response_ScanLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ScanLock != nil { dAtA[i] = 0x4a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.ScanLock.Size())) n44, err := m.ScanLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n44 } return i, nil } func (m *BatchCommandsResponse_Response_ResolveLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.ResolveLock != nil { dAtA[i] = 0x52 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.ResolveLock.Size())) n45, err := m.ResolveLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n45 } return i, nil } func (m *BatchCommandsResponse_Response_GC) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.GC != nil { dAtA[i] = 0x5a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.GC.Size())) n46, err := m.GC.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n46 } return i, nil } func (m *BatchCommandsResponse_Response_DeleteRange) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.DeleteRange != nil { dAtA[i] = 0x62 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.DeleteRange.Size())) n47, err := m.DeleteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n47 } return i, nil } func (m *BatchCommandsResponse_Response_RawGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawGet != nil { dAtA[i] = 0x6a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawGet.Size())) n48, err := m.RawGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n48 } return i, nil } func (m *BatchCommandsResponse_Response_RawBatchGet) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchGet != nil { dAtA[i] = 0x72 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchGet.Size())) n49, err := m.RawBatchGet.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n49 } return i, nil } func (m *BatchCommandsResponse_Response_RawPut) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawPut != nil { dAtA[i] = 0x7a i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawPut.Size())) n50, err := m.RawPut.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n50 } return i, nil } func (m *BatchCommandsResponse_Response_RawBatchPut) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchPut != nil { dAtA[i] = 0x82 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchPut.Size())) n51, err := m.RawBatchPut.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n51 } return i, nil } func (m *BatchCommandsResponse_Response_RawDelete) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawDelete != nil { dAtA[i] = 0x8a i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDelete.Size())) n52, err := m.RawDelete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n52 } return i, nil } func (m *BatchCommandsResponse_Response_RawBatchDelete) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchDelete != nil { dAtA[i] = 0x92 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchDelete.Size())) n53, err := m.RawBatchDelete.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n53 } return i, nil } func (m *BatchCommandsResponse_Response_RawScan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawScan != nil { dAtA[i] = 0x9a i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawScan.Size())) n54, err := m.RawScan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n54 } return i, nil } func (m *BatchCommandsResponse_Response_RawDeleteRange) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawDeleteRange != nil { dAtA[i] = 0xa2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDeleteRange.Size())) n55, err := m.RawDeleteRange.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n55 } return i, nil } func (m *BatchCommandsResponse_Response_RawBatchScan) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawBatchScan != nil { dAtA[i] = 0xaa i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchScan.Size())) n56, err := m.RawBatchScan.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n56 } return i, nil } func (m *BatchCommandsResponse_Response_Coprocessor) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Coprocessor != nil { dAtA[i] = 0xb2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Coprocessor.Size())) n57, err := m.Coprocessor.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n57 } return i, nil } func (m *BatchCommandsResponse_Response_PessimisticLock) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.PessimisticLock != nil { dAtA[i] = 0xba i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticLock.Size())) n58, err := m.PessimisticLock.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n58 } return i, nil } func (m *BatchCommandsResponse_Response_PessimisticRollback) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.PessimisticRollback != nil { dAtA[i] = 0xc2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticRollback.Size())) n59, err := m.PessimisticRollback.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n59 } return i, nil } func (m *BatchCommandsResponse_Response_CheckTxnStatus) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CheckTxnStatus != nil { dAtA[i] = 0xca i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckTxnStatus.Size())) n60, err := m.CheckTxnStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n60 } return i, nil } func (m *BatchCommandsResponse_Response_TxnHeartBeat) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.TxnHeartBeat != nil { dAtA[i] = 0xd2 i++ dAtA[i] = 0x1 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.TxnHeartBeat.Size())) n61, err := m.TxnHeartBeat.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n61 } return i, nil } func (m *BatchCommandsResponse_Response_CheckSecondaryLocks) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.CheckSecondaryLocks != nil { dAtA[i] = 0x8a i++ dAtA[i] = 0x2 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckSecondaryLocks.Size())) n62, err := m.CheckSecondaryLocks.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n62 } return i, nil } func (m *BatchCommandsResponse_Response_RawCoprocessor) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.RawCoprocessor != nil { dAtA[i] = 0x92 i++ dAtA[i] = 0x2 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.RawCoprocessor.Size())) n63, err := m.RawCoprocessor.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n63 } return i, nil } func (m *BatchCommandsResponse_Response_Empty) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Empty != nil { dAtA[i] = 0xfa i++ dAtA[i] = 0xf i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.Empty.Size())) n64, err := m.Empty.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n64 } return i, nil } func (m *BatchRaftMessage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchRaftMessage) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Msgs) > 0 { for _, msg := range m.Msgs { dAtA[i] = 0xa i++ i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsEmptyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsEmptyRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TestId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.TestId)) } if m.DelayTime != 0 { dAtA[i] = 0x10 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.DelayTime)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *BatchCommandsEmptyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *BatchCommandsEmptyResponse) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TestId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintTikvpb(dAtA, i, uint64(m.TestId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintTikvpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *BatchCommandsRequest) Size() (n int) { var l int _ = l if len(m.Requests) > 0 { for _, e := range m.Requests { l = e.Size() n += 1 + l + sovTikvpb(uint64(l)) } } if len(m.RequestIds) > 0 { l = 0 for _, e := range m.RequestIds { l += sovTikvpb(uint64(e)) } n += 1 + sovTikvpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsRequest_Request) Size() (n int) { var l int _ = l if m.Cmd != nil { n += m.Cmd.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsRequest_Request_Get) Size() (n int) { var l int _ = l if m.Get != nil { l = m.Get.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Scan) Size() (n int) { var l int _ = l if m.Scan != nil { l = m.Scan.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Prewrite) Size() (n int) { var l int _ = l if m.Prewrite != nil { l = m.Prewrite.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Commit) Size() (n int) { var l int _ = l if m.Commit != nil { l = m.Commit.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Import) Size() (n int) { var l int _ = l if m.Import != nil { l = m.Import.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Cleanup) Size() (n int) { var l int _ = l if m.Cleanup != nil { l = m.Cleanup.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_BatchGet) Size() (n int) { var l int _ = l if m.BatchGet != nil { l = m.BatchGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_BatchRollback) Size() (n int) { var l int _ = l if m.BatchRollback != nil { l = m.BatchRollback.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_ScanLock) Size() (n int) { var l int _ = l if m.ScanLock != nil { l = m.ScanLock.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_ResolveLock) Size() (n int) { var l int _ = l if m.ResolveLock != nil { l = m.ResolveLock.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_GC) Size() (n int) { var l int _ = l if m.GC != nil { l = m.GC.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_DeleteRange) Size() (n int) { var l int _ = l if m.DeleteRange != nil { l = m.DeleteRange.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawGet) Size() (n int) { var l int _ = l if m.RawGet != nil { l = m.RawGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawBatchGet) Size() (n int) { var l int _ = l if m.RawBatchGet != nil { l = m.RawBatchGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawPut) Size() (n int) { var l int _ = l if m.RawPut != nil { l = m.RawPut.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawBatchPut) Size() (n int) { var l int _ = l if m.RawBatchPut != nil { l = m.RawBatchPut.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawDelete) Size() (n int) { var l int _ = l if m.RawDelete != nil { l = m.RawDelete.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawBatchDelete) Size() (n int) { var l int _ = l if m.RawBatchDelete != nil { l = m.RawBatchDelete.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawScan) Size() (n int) { var l int _ = l if m.RawScan != nil { l = m.RawScan.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawDeleteRange) Size() (n int) { var l int _ = l if m.RawDeleteRange != nil { l = m.RawDeleteRange.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawBatchScan) Size() (n int) { var l int _ = l if m.RawBatchScan != nil { l = m.RawBatchScan.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Coprocessor) Size() (n int) { var l int _ = l if m.Coprocessor != nil { l = m.Coprocessor.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_PessimisticLock) Size() (n int) { var l int _ = l if m.PessimisticLock != nil { l = m.PessimisticLock.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_PessimisticRollback) Size() (n int) { var l int _ = l if m.PessimisticRollback != nil { l = m.PessimisticRollback.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_CheckTxnStatus) Size() (n int) { var l int _ = l if m.CheckTxnStatus != nil { l = m.CheckTxnStatus.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_TxnHeartBeat) Size() (n int) { var l int _ = l if m.TxnHeartBeat != nil { l = m.TxnHeartBeat.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_CheckSecondaryLocks) Size() (n int) { var l int _ = l if m.CheckSecondaryLocks != nil { l = m.CheckSecondaryLocks.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_RawCoprocessor) Size() (n int) { var l int _ = l if m.RawCoprocessor != nil { l = m.RawCoprocessor.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsRequest_Request_Empty) Size() (n int) { var l int _ = l if m.Empty != nil { l = m.Empty.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse) Size() (n int) { var l int _ = l if len(m.Responses) > 0 { for _, e := range m.Responses { l = e.Size() n += 1 + l + sovTikvpb(uint64(l)) } } if len(m.RequestIds) > 0 { l = 0 for _, e := range m.RequestIds { l += sovTikvpb(uint64(e)) } n += 1 + sovTikvpb(uint64(l)) + l } if m.TransportLayerLoad != 0 { n += 1 + sovTikvpb(uint64(m.TransportLayerLoad)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsResponse_Response) Size() (n int) { var l int _ = l if m.Cmd != nil { n += m.Cmd.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsResponse_Response_Get) Size() (n int) { var l int _ = l if m.Get != nil { l = m.Get.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Scan) Size() (n int) { var l int _ = l if m.Scan != nil { l = m.Scan.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Prewrite) Size() (n int) { var l int _ = l if m.Prewrite != nil { l = m.Prewrite.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Commit) Size() (n int) { var l int _ = l if m.Commit != nil { l = m.Commit.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Import) Size() (n int) { var l int _ = l if m.Import != nil { l = m.Import.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Cleanup) Size() (n int) { var l int _ = l if m.Cleanup != nil { l = m.Cleanup.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_BatchGet) Size() (n int) { var l int _ = l if m.BatchGet != nil { l = m.BatchGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_BatchRollback) Size() (n int) { var l int _ = l if m.BatchRollback != nil { l = m.BatchRollback.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_ScanLock) Size() (n int) { var l int _ = l if m.ScanLock != nil { l = m.ScanLock.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_ResolveLock) Size() (n int) { var l int _ = l if m.ResolveLock != nil { l = m.ResolveLock.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_GC) Size() (n int) { var l int _ = l if m.GC != nil { l = m.GC.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_DeleteRange) Size() (n int) { var l int _ = l if m.DeleteRange != nil { l = m.DeleteRange.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawGet) Size() (n int) { var l int _ = l if m.RawGet != nil { l = m.RawGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawBatchGet) Size() (n int) { var l int _ = l if m.RawBatchGet != nil { l = m.RawBatchGet.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawPut) Size() (n int) { var l int _ = l if m.RawPut != nil { l = m.RawPut.Size() n += 1 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawBatchPut) Size() (n int) { var l int _ = l if m.RawBatchPut != nil { l = m.RawBatchPut.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawDelete) Size() (n int) { var l int _ = l if m.RawDelete != nil { l = m.RawDelete.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawBatchDelete) Size() (n int) { var l int _ = l if m.RawBatchDelete != nil { l = m.RawBatchDelete.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawScan) Size() (n int) { var l int _ = l if m.RawScan != nil { l = m.RawScan.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawDeleteRange) Size() (n int) { var l int _ = l if m.RawDeleteRange != nil { l = m.RawDeleteRange.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawBatchScan) Size() (n int) { var l int _ = l if m.RawBatchScan != nil { l = m.RawBatchScan.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Coprocessor) Size() (n int) { var l int _ = l if m.Coprocessor != nil { l = m.Coprocessor.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_PessimisticLock) Size() (n int) { var l int _ = l if m.PessimisticLock != nil { l = m.PessimisticLock.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_PessimisticRollback) Size() (n int) { var l int _ = l if m.PessimisticRollback != nil { l = m.PessimisticRollback.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_CheckTxnStatus) Size() (n int) { var l int _ = l if m.CheckTxnStatus != nil { l = m.CheckTxnStatus.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_TxnHeartBeat) Size() (n int) { var l int _ = l if m.TxnHeartBeat != nil { l = m.TxnHeartBeat.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_CheckSecondaryLocks) Size() (n int) { var l int _ = l if m.CheckSecondaryLocks != nil { l = m.CheckSecondaryLocks.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_RawCoprocessor) Size() (n int) { var l int _ = l if m.RawCoprocessor != nil { l = m.RawCoprocessor.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchCommandsResponse_Response_Empty) Size() (n int) { var l int _ = l if m.Empty != nil { l = m.Empty.Size() n += 2 + l + sovTikvpb(uint64(l)) } return n } func (m *BatchRaftMessage) Size() (n int) { var l int _ = l if len(m.Msgs) > 0 { for _, e := range m.Msgs { l = e.Size() n += 1 + l + sovTikvpb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsEmptyRequest) Size() (n int) { var l int _ = l if m.TestId != 0 { n += 1 + sovTikvpb(uint64(m.TestId)) } if m.DelayTime != 0 { n += 1 + sovTikvpb(uint64(m.DelayTime)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *BatchCommandsEmptyResponse) Size() (n int) { var l int _ = l if m.TestId != 0 { n += 1 + sovTikvpb(uint64(m.TestId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTikvpb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozTikvpb(x uint64) (n int) { return sovTikvpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *BatchCommandsRequest) 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 ErrIntOverflowTikvpb } 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: BatchCommandsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchCommandsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Requests = append(m.Requests, &BatchCommandsRequest_Request{}) if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RequestIds = append(m.RequestIds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RequestIds = append(m.RequestIds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType) } default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchCommandsRequest_Request) 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 ErrIntOverflowTikvpb } 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: Request: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.GetRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Get{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Scan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ScanRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Scan{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PrewriteRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Prewrite{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CommitRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Commit{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Import", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ImportRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Import{v} iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cleanup", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CleanupRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Cleanup{v} iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BatchGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.BatchGetRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_BatchGet{v} iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BatchRollback", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.BatchRollbackRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_BatchRollback{v} iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ScanLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ScanLockRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_ScanLock{v} iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResolveLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ResolveLockRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_ResolveLock{v} iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GC", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.GCRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_GC{v} iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.DeleteRangeRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_DeleteRange{v} iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawGetRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawGet{v} iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchGetRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawBatchGet{v} iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawPut", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawPutRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawPut{v} iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchPut", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchPutRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawBatchPut{v} iNdEx = postIndex case 17: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawDeleteRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawDelete{v} iNdEx = postIndex case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchDeleteRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawBatchDelete{v} iNdEx = postIndex case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawScan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawScanRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawScan{v} iNdEx = postIndex case 20: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawDeleteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawDeleteRangeRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawDeleteRange{v} iNdEx = postIndex case 21: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchScan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchScanRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawBatchScan{v} iNdEx = postIndex case 22: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Coprocessor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &coprocessor.Request{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Coprocessor{v} iNdEx = postIndex case 23: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PessimisticLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PessimisticLockRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_PessimisticLock{v} iNdEx = postIndex case 24: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PessimisticRollback", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PessimisticRollbackRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_PessimisticRollback{v} iNdEx = postIndex case 25: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckTxnStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CheckTxnStatusRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_CheckTxnStatus{v} iNdEx = postIndex case 26: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnHeartBeat", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.TxnHeartBeatRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_TxnHeartBeat{v} iNdEx = postIndex case 33: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckSecondaryLocks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CheckSecondaryLocksRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_CheckSecondaryLocks{v} iNdEx = postIndex case 34: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawCoprocessor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawCoprocessorRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_RawCoprocessor{v} iNdEx = postIndex case 255: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &BatchCommandsEmptyRequest{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsRequest_Request_Empty{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchCommandsResponse) 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 ErrIntOverflowTikvpb } 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: BatchCommandsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchCommandsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Responses = append(m.Responses, &BatchCommandsResponse_Response{}) if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RequestIds = append(m.RequestIds, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + packedLen if postIndex > l { return io.ErrUnexpectedEOF } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } m.RequestIds = append(m.RequestIds, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType) } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TransportLayerLoad", wireType) } m.TransportLayerLoad = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TransportLayerLoad |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchCommandsResponse_Response) 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 ErrIntOverflowTikvpb } 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: Response: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.GetResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Get{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Scan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ScanResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Scan{v} iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PrewriteResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Prewrite{v} iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CommitResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Commit{v} iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Import", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ImportResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Import{v} iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cleanup", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CleanupResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Cleanup{v} iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BatchGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.BatchGetResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_BatchGet{v} iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BatchRollback", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.BatchRollbackResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_BatchRollback{v} iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ScanLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ScanLockResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_ScanLock{v} iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResolveLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.ResolveLockResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_ResolveLock{v} iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GC", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.GCResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_GC{v} iNdEx = postIndex case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.DeleteRangeResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_DeleteRange{v} iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawGetResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawGet{v} iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchGet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchGetResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawBatchGet{v} iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawPut", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawPutResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawPut{v} iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchPut", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchPutResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawBatchPut{v} iNdEx = postIndex case 17: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawDeleteResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawDelete{v} iNdEx = postIndex case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchDeleteResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawBatchDelete{v} iNdEx = postIndex case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawScan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawScanResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawScan{v} iNdEx = postIndex case 20: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawDeleteRange", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawDeleteRangeResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawDeleteRange{v} iNdEx = postIndex case 21: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawBatchScan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawBatchScanResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawBatchScan{v} iNdEx = postIndex case 22: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Coprocessor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &coprocessor.Response{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Coprocessor{v} iNdEx = postIndex case 23: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PessimisticLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PessimisticLockResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_PessimisticLock{v} iNdEx = postIndex case 24: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PessimisticRollback", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.PessimisticRollbackResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_PessimisticRollback{v} iNdEx = postIndex case 25: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckTxnStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CheckTxnStatusResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_CheckTxnStatus{v} iNdEx = postIndex case 26: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxnHeartBeat", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.TxnHeartBeatResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_TxnHeartBeat{v} iNdEx = postIndex case 33: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckSecondaryLocks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.CheckSecondaryLocksResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_CheckSecondaryLocks{v} iNdEx = postIndex case 34: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RawCoprocessor", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &kvrpcpb.RawCoprocessorResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_RawCoprocessor{v} iNdEx = postIndex case 255: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &BatchCommandsEmptyResponse{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.Cmd = &BatchCommandsResponse_Response_Empty{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchRaftMessage) 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 ErrIntOverflowTikvpb } 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: BatchRaftMessage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchRaftMessage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Msgs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTikvpb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Msgs = append(m.Msgs, &raft_serverpb.RaftMessage{}) if err := m.Msgs[len(m.Msgs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchCommandsEmptyRequest) 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 ErrIntOverflowTikvpb } 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: BatchCommandsEmptyRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchCommandsEmptyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TestId", wireType) } m.TestId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TestId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DelayTime", wireType) } m.DelayTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DelayTime |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 *BatchCommandsEmptyResponse) 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 ErrIntOverflowTikvpb } 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: BatchCommandsEmptyResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: BatchCommandsEmptyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TestId", wireType) } m.TestId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTikvpb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TestId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTikvpb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTikvpb } 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 skipTikvpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTikvpb } 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, ErrIntOverflowTikvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTikvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthTikvpb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTikvpb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipTikvpb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthTikvpb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTikvpb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("tikvpb.proto", fileDescriptor_tikvpb_92b152ac586f1929) } var fileDescriptor_tikvpb_92b152ac586f1929 = []byte{ // 2183 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x9a, 0xdb, 0x52, 0x1b, 0xc9, 0x19, 0x80, 0x47, 0xb6, 0xcc, 0xa1, 0x31, 0xa7, 0x06, 0xcc, 0xd0, 0xcb, 0xc1, 0xcc, 0xb2, 0x1b, 0x2a, 0xa9, 0x22, 0xc6, 0xeb, 0xac, 0xb3, 0xbb, 0xc9, 0x06, 0x23, 0xbc, 0x80, 0x05, 0xb5, 0x2a, 0x49, 0x9b, 0x75, 0xaa, 0x52, 0x45, 0x35, 0x52, 0x03, 0x2a, 0xa4, 0x19, 0x65, 0xa6, 0x19, 0xac, 0xd7, 0xc8, 0x45, 0x2a, 0x8f, 0x90, 0x07, 0xc8, 0x43, 0xe4, 0x22, 0x17, 0xb9, 0xcc, 0x65, 0xca, 0xb9, 0xc8, 0x63, 0x24, 0xd5, 0x3d, 0x33, 0x3d, 0xdd, 0x3d, 0xdd, 0x23, 0x72, 0xc5, 0xe8, 0x3f, 0xf6, 0xf9, 0xfb, 0xbb, 0x6d, 0xf0, 0x94, 0xf6, 0x6e, 0xe3, 0xe1, 0xe5, 0xde, 0x30, 0x0c, 0x68, 0x00, 0x27, 0x92, 0x5f, 0x68, 0xb1, 0x13, 0x0c, 0xc3, 0xa0, 0x43, 0xa2, 0x28, 0x08, 0x13, 0x15, 0x9a, 0xbd, 0x8d, 0xc3, 0x61, 0x27, 0xb3, 0x44, 0xd3, 0x83, 0xe1, 0x30, 0xfd, 0x5c, 0x0a, 0xf1, 0x15, 0xbd, 0x88, 0x48, 0x18, 0x93, 0x50, 0xe8, 0x97, 0xaf, 0x83, 0xeb, 0x80, 0x7f, 0xfe, 0x9c, 0x7d, 0xa5, 0xd2, 0xf9, 0xf0, 0x2e, 0xa2, 0xfc, 0x33, 0x11, 0x78, 0x7f, 0x9c, 0x07, 0xcb, 0x87, 0x98, 0x76, 0x6e, 0x6a, 0xc1, 0x60, 0x80, 0xfd, 0x6e, 0xd4, 0x24, 0x7f, 0xb8, 0x23, 0x11, 0x85, 0x07, 0x60, 0x2a, 0x4c, 0x3e, 0x23, 0xb7, 0xf2, 0xfc, 0xf1, 0xee, 0xcc, 0xcb, 0x9d, 0xbd, 0xb4, 0xa9, 0x26, 0xfb, 0xbd, 0xf4, 0x6f, 0x53, 0x78, 0xc1, 0x2d, 0x30, 0x93, 0x7e, 0x5f, 0xf4, 0xba, 0x91, 0xfb, 0xe8, 0xf9, 0xe3, 0xdd, 0x6a, 0x13, 0xa4, 0xa2, 0xd3, 0x6e, 0x84, 0xfe, 0x34, 0x07, 0x26, 0xb3, 0x74, 0x3f, 0x01, 0x8f, 0x8f, 0x09, 0x75, 0x2b, 0xcf, 0x2b, 0xbb, 0x33, 0x2f, 0x97, 0xf6, 0xb2, 0xbe, 0x1e, 0x13, 0x9a, 0x5a, 0x9c, 0x38, 0x4d, 0x66, 0x01, 0x7f, 0x0a, 0xaa, 0xad, 0x0e, 0xf6, 0xdd, 0x47, 0xdc, 0x72, 0x59, 0x58, 0x32, 0x61, 0x6e, 0xca, 0x6d, 0xe0, 0x97, 0x60, 0xaa, 0x11, 0x92, 0xfb, 0xb0, 0x47, 0x89, 0xfb, 0x98, 0xdb, 0xbb, 0xc2, 0x3e, 0x53, 0xe4, 0x3e, 0xc2, 0x16, 0xbe, 0x00, 0x13, 0xac, 0x7b, 0x3d, 0xea, 0x56, 0xb9, 0xd7, 0x33, 0xe1, 0x95, 0x88, 0x73, 0x9f, 0xd4, 0x8e, 0x79, 0x9c, 0x0e, 0x86, 0x41, 0x48, 0xdd, 0x27, 0x9a, 0x47, 0x22, 0x96, 0x3c, 0x12, 0x01, 0xfc, 0x02, 0x4c, 0xd6, 0xfa, 0x04, 0xfb, 0x77, 0x43, 0x77, 0x82, 0xbb, 0xac, 0xe6, 0x49, 0x12, 0x79, 0xee, 0x93, 0x59, 0xb2, 0x0e, 0xf1, 0xc1, 0x67, 0x43, 0x35, 0xa9, 0x75, 0x28, 0x53, 0x48, 0x1d, 0xca, 0x44, 0xf0, 0x2d, 0x98, 0xe5, 0xdf, 0xcd, 0xa0, 0xdf, 0xbf, 0xc4, 0x9d, 0x5b, 0x77, 0x8a, 0x3b, 0x6f, 0xa8, 0xce, 0x99, 0x36, 0x8f, 0xa0, 0x7a, 0xb1, 0xf4, 0x6c, 0x5c, 0xcf, 0x82, 0xce, 0xad, 0x3b, 0xad, 0xa5, 0xcf, 0x14, 0x52, 0xfa, 0x4c, 0x04, 0x7f, 0x03, 0x66, 0x9a, 0x24, 0x0a, 0xfa, 0x31, 0xe1, 0xae, 0x80, 0xbb, 0x7e, 0x22, 0x5c, 0x25, 0x5d, 0xee, 0x2d, 0x7b, 0xc0, 0x1d, 0xf0, 0xe8, 0xb8, 0xe6, 0xce, 0x70, 0x3f, 0x98, 0x2f, 0x8e, 0x5a, 0x6e, 0xfe, 0xe8, 0xb8, 0xc6, 0xd2, 0x1c, 0x91, 0x3e, 0xa1, 0xa4, 0x89, 0xfd, 0x6b, 0xe2, 0x3e, 0xd5, 0xd2, 0x48, 0x3a, 0x29, 0x8d, 0x24, 0x65, 0xb3, 0xd8, 0xc4, 0xf7, 0x6c, 0x70, 0x67, 0xb5, 0x59, 0x4c, 0xc4, 0xd2, 0x2c, 0x26, 0x02, 0xde, 0x33, 0x7c, 0x2f, 0xe6, 0x64, 0x4e, 0xef, 0x59, 0xae, 0x93, 0x7b, 0x96, 0x4b, 0xd3, 0x94, 0x8d, 0x3b, 0xea, 0xce, 0x17, 0x53, 0x36, 0xee, 0xb4, 0x94, 0x8d, 0x3b, 0x25, 0x25, 0x73, 0x5b, 0xb0, 0xa4, 0x54, 0x7c, 0x65, 0x0f, 0xf8, 0x15, 0x98, 0x6e, 0xe2, 0xfb, 0xa4, 0xdf, 0xee, 0x22, 0x77, 0x5f, 0x93, 0xdd, 0xd3, 0x11, 0x11, 0xce, 0xb9, 0x35, 0x3c, 0x01, 0x73, 0x59, 0xa4, 0xd4, 0x1f, 0x72, 0xff, 0xcd, 0x42, 0x7a, 0x3d, 0x88, 0xe6, 0xc7, 0x96, 0x7f, 0x13, 0xdf, 0xf3, 0x9d, 0xbc, 0xa4, 0x2d, 0xff, 0x54, 0x2e, 0x2d, 0xff, 0x54, 0x92, 0xa6, 0x97, 0xe7, 0x78, 0xb9, 0x98, 0xde, 0x38, 0xcd, 0x9a, 0x1f, 0x3c, 0x04, 0x4f, 0xb3, 0x06, 0xf1, 0x36, 0xac, 0xf0, 0x38, 0xeb, 0x85, 0x6e, 0xa8, 0x0d, 0x51, 0x7c, 0xe0, 0x2f, 0xc1, 0x4c, 0x2d, 0x3f, 0xa5, 0xdd, 0x67, 0xe9, 0x81, 0x24, 0x9f, 0xdc, 0xd2, 0x0c, 0x48, 0xa6, 0xb0, 0x0e, 0xe6, 0x1b, 0x24, 0x8a, 0x7a, 0x83, 0x5e, 0x44, 0x7b, 0x1d, 0xbe, 0x27, 0x56, 0xb9, 0xf7, 0x56, 0x7e, 0x3c, 0xa9, 0xfa, 0x3c, 0x90, 0xee, 0x09, 0x7f, 0x04, 0x4b, 0x92, 0x48, 0xec, 0x70, 0x97, 0x07, 0xfc, 0xd4, 0x14, 0xb0, 0xb8, 0xcf, 0x4d, 0x11, 0xd8, 0x68, 0xd7, 0x6e, 0x48, 0xe7, 0xb6, 0xfd, 0xc1, 0x6f, 0x51, 0x4c, 0xef, 0x22, 0x77, 0x4d, 0x1b, 0x6d, 0x55, 0x2d, 0x8d, 0xb6, 0xaa, 0x60, 0xa3, 0xdd, 0xfe, 0xe0, 0x9f, 0x10, 0x1c, 0xd2, 0x43, 0x82, 0xa9, 0x8b, 0xb4, 0xd1, 0x96, 0x95, 0xd2, 0x68, 0xcb, 0x62, 0xd6, 0x4d, 0x1e, 0xb5, 0x45, 0x3a, 0x81, 0xdf, 0xc5, 0xe1, 0x88, 0x75, 0x3e, 0x72, 0xb7, 0xb5, 0x6e, 0x1a, 0x6c, 0xa4, 0x6e, 0x1a, 0xb4, 0xe9, 0xa2, 0x92, 0x67, 0xd2, 0x2b, 0x2e, 0x2a, 0x49, 0xad, 0x2e, 0x2a, 0x79, 0x5a, 0xbf, 0x06, 0x4f, 0xde, 0x0e, 0x86, 0x74, 0xe4, 0xfe, 0x37, 0xc1, 0xd8, 0xb6, 0x11, 0x98, 0xdc, 0x24, 0x0f, 0x92, 0xb8, 0x1c, 0x3e, 0x01, 0x8f, 0x3b, 0x83, 0xee, 0xbb, 0xea, 0xd4, 0x27, 0x0b, 0xdb, 0xde, 0x7f, 0xe6, 0xc1, 0x8a, 0x06, 0xd9, 0x68, 0x18, 0xf8, 0x11, 0x81, 0x47, 0x60, 0x3a, 0x4c, 0xbf, 0x33, 0x2c, 0x7f, 0x6e, 0xc1, 0x72, 0x62, 0xb5, 0x97, 0x7d, 0x34, 0x73, 0xc7, 0xb1, 0x64, 0x86, 0x2f, 0xc0, 0x32, 0x0d, 0xb1, 0x1f, 0x31, 0x52, 0x5d, 0xf4, 0xf1, 0x88, 0x84, 0x17, 0xfd, 0x00, 0x77, 0x39, 0x44, 0xab, 0x4d, 0x28, 0x74, 0x67, 0x4c, 0x75, 0x16, 0xe0, 0x2e, 0xfa, 0xeb, 0x1c, 0x98, 0x12, 0xad, 0xdc, 0x95, 0x61, 0xbe, 0xac, 0xc2, 0x3c, 0x31, 0xc9, 0x68, 0xfe, 0x33, 0x85, 0xe6, 0x2b, 0x1a, 0xcd, 0x85, 0x6d, 0x82, 0xf3, 0xd7, 0x05, 0x9c, 0xaf, 0x19, 0x70, 0x2e, 0x9c, 0x72, 0x9e, 0xef, 0x6b, 0x3c, 0x5f, 0x2d, 0xf0, 0x5c, 0x38, 0x65, 0x40, 0xdf, 0xd7, 0x80, 0xbe, 0x5a, 0x00, 0x7a, 0xee, 0x92, 0x12, 0xfd, 0x95, 0x4e, 0x74, 0xb7, 0x48, 0x74, 0xe1, 0x24, 0x90, 0xfe, 0xba, 0x80, 0xf4, 0x35, 0x03, 0xd2, 0xf3, 0x4e, 0x09, 0x72, 0x7c, 0x67, 0x66, 0xfa, 0xa6, 0x8d, 0xe9, 0x22, 0x84, 0x06, 0xf5, 0xd7, 0x05, 0xa8, 0xaf, 0x19, 0xa0, 0x9e, 0x37, 0x40, 0x50, 0xfd, 0xc0, 0x44, 0xf5, 0x75, 0x33, 0xd5, 0x85, 0xbb, 0x82, 0xf5, 0xcf, 0x24, 0xac, 0x2f, 0x29, 0x58, 0x17, 0xf6, 0x8c, 0xeb, 0x07, 0x26, 0xae, 0xaf, 0x9b, 0xb9, 0x9e, 0x27, 0x92, 0x8f, 0xfb, 0x7d, 0x0d, 0xec, 0xab, 0x05, 0xb0, 0xe7, 0xb3, 0x99, 0x92, 0xfd, 0xc0, 0x44, 0xf6, 0x75, 0x33, 0xd9, 0xa5, 0xde, 0x49, 0x68, 0xdf, 0xd7, 0xd0, 0xbe, 0x5a, 0x40, 0xbb, 0x92, 0x94, 0xa1, 0xf9, 0xc0, 0xc4, 0xf6, 0x75, 0x33, 0xdb, 0x8b, 0x49, 0x59, 0x84, 0xaf, 0x8b, 0x70, 0x47, 0x26, 0xb8, 0x0b, 0x6f, 0x89, 0xee, 0xa7, 0x16, 0xba, 0x6f, 0x59, 0xe9, 0x2e, 0xa2, 0xe8, 0x78, 0x7f, 0xa5, 0xe3, 0xdd, 0x2d, 0xe2, 0x3d, 0xdf, 0x0b, 0x19, 0xdf, 0x4f, 0x2d, 0x7c, 0xdf, 0xb2, 0xf2, 0x5d, 0x69, 0x80, 0x3c, 0xe3, 0x35, 0x23, 0xe0, 0x37, 0x2c, 0x80, 0x17, 0x61, 0x54, 0xc2, 0x7f, 0x65, 0x22, 0xfc, 0x8a, 0x46, 0xf8, 0x7c, 0x1e, 0x64, 0x16, 0x9c, 0xd9, 0x10, 0xff, 0xdc, 0x8e, 0x78, 0x11, 0xa9, 0xc0, 0xf8, 0xf7, 0x65, 0x8c, 0xdf, 0x29, 0x67, 0xbc, 0x88, 0x6a, 0x84, 0xfc, 0xa9, 0x05, 0xf2, 0x5b, 0x56, 0xc8, 0xe7, 0x43, 0xae, 0x51, 0xbe, 0x66, 0xa4, 0xfc, 0x86, 0x85, 0xf2, 0xf9, 0x90, 0x2b, 0x98, 0x7f, 0x5f, 0x86, 0xf9, 0x9d, 0x72, 0xcc, 0xe7, 0x3d, 0x35, 0x71, 0xfe, 0xd4, 0xc2, 0xf9, 0x2d, 0x2b, 0xe7, 0x95, 0xc5, 0x25, 0x4f, 0xee, 0x37, 0x1a, 0xe8, 0xbd, 0x32, 0xd0, 0x8b, 0x28, 0x26, 0xd2, 0x1f, 0x82, 0x85, 0xe4, 0x34, 0xc6, 0x57, 0xf4, 0x9c, 0x44, 0x11, 0xbe, 0x26, 0x70, 0x0f, 0x54, 0x07, 0xd1, 0x75, 0x86, 0x77, 0xb4, 0xa7, 0xde, 0xee, 0x25, 0xcb, 0x26, 0xb7, 0xf3, 0x5a, 0x60, 0xcd, 0x5a, 0x60, 0xc0, 0x55, 0x30, 0x49, 0x13, 0xce, 0x73, 0x1c, 0x57, 0x9b, 0x13, 0x94, 0x33, 0x1e, 0x6e, 0x00, 0xd0, 0x25, 0x7d, 0x3c, 0xba, 0xa0, 0xbd, 0x01, 0xe1, 0xfc, 0xad, 0x36, 0xa7, 0xb9, 0xa4, 0xdd, 0x1b, 0x10, 0xef, 0x17, 0x00, 0xd9, 0x3b, 0x63, 0x8d, 0xfa, 0xf2, 0xef, 0x5b, 0xa0, 0xda, 0xee, 0xdd, 0xc6, 0xf0, 0x15, 0x78, 0x52, 0x8f, 0xd9, 0x29, 0x68, 0xba, 0xcb, 0x23, 0x63, 0x4d, 0xe0, 0x39, 0xf0, 0x35, 0x98, 0xa8, 0xc7, 0x7c, 0xeb, 0x19, 0x2f, 0xf6, 0xc8, 0x5c, 0x20, 0x78, 0x0e, 0xac, 0x01, 0x50, 0x8f, 0x05, 0xef, 0xad, 0xb7, 0x7c, 0x64, 0x2f, 0x18, 0x3c, 0x07, 0xbe, 0x07, 0x8b, 0xf5, 0x58, 0xdf, 0x7a, 0xe3, 0x4a, 0x72, 0x34, 0x76, 0x43, 0x7b, 0x0e, 0xec, 0x82, 0x95, 0xfa, 0x6f, 0x4d, 0xdb, 0xef, 0x21, 0xf5, 0x39, 0x7a, 0xd0, 0x06, 0xf7, 0x1c, 0xf8, 0x3d, 0x98, 0xab, 0xc7, 0xca, 0x6e, 0x2a, 0x2d, 0xb1, 0x51, 0xf9, 0xd6, 0xf4, 0x1c, 0xf8, 0x03, 0x58, 0xa8, 0xc7, 0xda, 0x2e, 0x1f, 0x53, 0xfd, 0xa3, 0x71, 0x07, 0x47, 0x3a, 0x1a, 0xb1, 0x69, 0x8b, 0x3e, 0xa4, 0x8c, 0x47, 0x0f, 0x3a, 0x04, 0x3c, 0x07, 0xfe, 0x1a, 0x4c, 0xd5, 0xe3, 0xb4, 0x9a, 0xb3, 0x3c, 0xe0, 0x20, 0x5b, 0x21, 0x98, 0xb9, 0xa7, 0x95, 0x9d, 0xe5, 0x35, 0x07, 0xd9, 0x8a, 0x42, 0xcf, 0x81, 0x07, 0x60, 0xba, 0x1e, 0x67, 0x35, 0x9e, 0xed, 0x69, 0x07, 0x59, 0x2b, 0xc4, 0x6c, 0x49, 0x8b, 0x62, 0xc2, 0xfa, 0xce, 0x83, 0xec, 0xe5, 0xa2, 0xe7, 0xc0, 0x26, 0x98, 0x4f, 0x83, 0x88, 0x25, 0x57, 0xfe, 0xe8, 0x83, 0xc6, 0xd4, 0x8f, 0x59, 0xc3, 0x44, 0x15, 0x68, 0x7d, 0x01, 0x42, 0xf6, 0x32, 0xd2, 0x73, 0xe0, 0x19, 0x98, 0xad, 0xc7, 0x72, 0x2d, 0x58, 0xf6, 0x1c, 0x84, 0x4a, 0xab, 0x4a, 0xcf, 0x81, 0xfb, 0xa0, 0x5a, 0x8f, 0x8f, 0x6b, 0xd0, 0xf0, 0x36, 0x84, 0x4c, 0x85, 0x65, 0xd6, 0x00, 0xb9, 0x62, 0x28, 0x7b, 0x28, 0x42, 0xa5, 0xd5, 0xa6, 0xe7, 0xc0, 0x6f, 0xb2, 0x02, 0x13, 0x5a, 0xde, 0x8c, 0x90, 0xad, 0xe4, 0xf4, 0x1c, 0xf8, 0x4e, 0x29, 0x35, 0x61, 0xd9, 0xf3, 0x11, 0x2a, 0xad, 0x40, 0x45, 0x43, 0x58, 0x25, 0x68, 0x79, 0x49, 0x42, 0xb6, 0x32, 0x54, 0x6d, 0x08, 0x8b, 0x50, 0xf6, 0xa8, 0x84, 0x4a, 0xab, 0x52, 0xcf, 0x61, 0x37, 0xd5, 0xbc, 0xb2, 0xb4, 0xbf, 0x2f, 0xa1, 0x92, 0xea, 0xd4, 0x73, 0x60, 0x4b, 0x2f, 0x49, 0xe1, 0x98, 0xa7, 0x26, 0x34, 0xae, 0x58, 0xf5, 0x1c, 0xf8, 0xad, 0x28, 0x4e, 0xa1, 0xed, 0xd5, 0x09, 0x59, 0xeb, 0x55, 0xd1, 0x28, 0x79, 0xed, 0x8c, 0x79, 0x80, 0x42, 0xe3, 0x0a, 0x58, 0xcf, 0x81, 0xe7, 0x6a, 0xc1, 0x0a, 0x4b, 0xdf, 0xa2, 0x50, 0x79, 0x21, 0x2b, 0xc2, 0x1d, 0x13, 0x5a, 0x27, 0xa3, 0x76, 0xfb, 0x4c, 0x0d, 0x27, 0xc4, 0xc6, 0x70, 0x92, 0x56, 0x84, 0xfb, 0x0e, 0x2c, 0xf2, 0x1a, 0x68, 0x30, 0xc4, 0x21, 0x79, 0xe3, 0x77, 0x5b, 0xf7, 0x78, 0xa8, 0xae, 0xb0, 0xda, 0x9b, 0x96, 0x71, 0x85, 0x71, 0xb9, 0xb6, 0xc2, 0xf8, 0xc1, 0x1d, 0xdd, 0x0d, 0xd4, 0x15, 0x96, 0x49, 0x8d, 0x2b, 0x2c, 0x57, 0x8a, 0x58, 0x17, 0x00, 0xfe, 0xe0, 0x47, 0xf8, 0x8a, 0x1c, 0x91, 0x88, 0x86, 0xc1, 0x28, 0x99, 0x0a, 0x4f, 0x78, 0x15, 0x95, 0x59, 0xe4, 0x4f, 0x4b, 0x6d, 0x44, 0x02, 0x02, 0x96, 0x9b, 0xe4, 0xba, 0x17, 0x51, 0x12, 0xb2, 0xf3, 0xe6, 0xfb, 0xcb, 0xa4, 0x08, 0x83, 0x3b, 0xd2, 0x69, 0x54, 0x54, 0x67, 0x49, 0x3e, 0x1b, 0x63, 0x25, 0xd2, 0xfc, 0x1e, 0x2c, 0xf2, 0xde, 0x29, 0x39, 0xb6, 0x55, 0xca, 0x99, 0x12, 0x78, 0x65, 0x26, 0xf2, 0x28, 0x35, 0xc9, 0x20, 0x48, 0x8e, 0x4c, 0x11, 0xde, 0x93, 0x1a, 0xa7, 0x2b, 0x8b, 0xa3, 0x64, 0xb2, 0x11, 0x09, 0x7e, 0x07, 0x16, 0x1a, 0x37, 0xa3, 0xa8, 0xd7, 0xc1, 0x7d, 0x01, 0x05, 0xa9, 0x26, 0xd2, 0x54, 0x59, 0xf0, 0xed, 0x12, 0x0b, 0x11, 0xfa, 0x57, 0xca, 0xfd, 0x0b, 0x1a, 0xdf, 0x56, 0x91, 0xf9, 0x3e, 0xc6, 0x4f, 0xa0, 0x45, 0xc9, 0xbb, 0x45, 0x43, 0x82, 0x07, 0xff, 0x67, 0x8c, 0x17, 0x15, 0x78, 0x9e, 0x56, 0xe8, 0x72, 0x43, 0xd6, 0x14, 0xf3, 0x84, 0x93, 0xe2, 0x38, 0x33, 0xa8, 0xa4, 0x70, 0x2d, 0xfd, 0x16, 0x02, 0xc7, 0xbc, 0x33, 0xa2, 0x71, 0xf7, 0x13, 0x7e, 0xe8, 0x57, 0xd9, 0xb5, 0x00, 0x96, 0xdc, 0x15, 0xd0, 0x92, 0xa6, 0x3b, 0x0a, 0x7c, 0xe2, 0x39, 0xbb, 0x15, 0xf8, 0x2d, 0x98, 0x16, 0x57, 0x10, 0xe8, 0x2a, 0x37, 0x99, 0x07, 0xf9, 0xbf, 0x01, 0x53, 0x2d, 0x1f, 0x0f, 0xa3, 0x9b, 0x80, 0xd5, 0x9b, 0xaa, 0x51, 0xa6, 0xa8, 0xdd, 0xdc, 0xf9, 0xb7, 0xf6, 0x10, 0xef, 0xc0, 0x4c, 0x6b, 0xd8, 0x67, 0xe5, 0xd7, 0x75, 0x2f, 0xf0, 0xa5, 0x53, 0x41, 0x92, 0x16, 0x4f, 0x05, 0x45, 0xa9, 0x70, 0x87, 0xe0, 0xee, 0xa9, 0xdf, 0x25, 0x1f, 0x64, 0xee, 0x64, 0x32, 0x03, 0x77, 0x72, 0x95, 0x7c, 0x7c, 0x9e, 0xc7, 0x9d, 0xce, 0x31, 0xa1, 0x87, 0xa3, 0x3a, 0x19, 0x49, 0xc7, 0xa7, 0x2c, 0x2e, 0x1e, 0x9f, 0xaa, 0x56, 0xde, 0x23, 0x42, 0xd3, 0xa2, 0x38, 0xa4, 0xed, 0x48, 0xda, 0x23, 0xba, 0xaa, 0xb8, 0x47, 0x8a, 0x16, 0x52, 0x85, 0x37, 0xab, 0x5c, 0xd4, 0xe0, 0x7a, 0xd9, 0x3f, 0xd3, 0xa2, 0x8d, 0xd2, 0xd7, 0x62, 0x36, 0x1b, 0x2f, 0x2a, 0xf0, 0x04, 0xcc, 0x1f, 0xf5, 0xa2, 0x21, 0xb3, 0x38, 0x6f, 0x34, 0xda, 0x38, 0x62, 0x65, 0xde, 0x60, 0x38, 0xdc, 0xcb, 0xa4, 0x4c, 0x94, 0x97, 0x79, 0x45, 0x8d, 0x68, 0xdd, 0x21, 0x98, 0xad, 0x61, 0xbf, 0x43, 0xfa, 0x59, 0x9c, 0x67, 0xdc, 0x3a, 0x91, 0xc9, 0x51, 0x56, 0x0b, 0x72, 0x11, 0xa3, 0x0d, 0x9e, 0xbd, 0x8d, 0x28, 0xbe, 0xec, 0xf7, 0x22, 0xd6, 0x9c, 0x5a, 0xe0, 0xfb, 0xa4, 0x43, 0xd9, 0x42, 0xf1, 0xb8, 0x93, 0x59, 0x99, 0x05, 0x86, 0xdc, 0xe6, 0xbc, 0xd1, 0x38, 0xc2, 0x14, 0x37, 0x70, 0xe7, 0x96, 0x50, 0xbe, 0x11, 0xbf, 0x04, 0x93, 0xa7, 0xd1, 0x9b, 0x7e, 0x2f, 0x26, 0x70, 0x89, 0x9b, 0xa4, 0xbf, 0xf2, 0x2b, 0xaa, 0x22, 0x14, 0xad, 0x39, 0x01, 0x33, 0xc9, 0x71, 0x4b, 0x70, 0x97, 0x84, 0xd2, 0x5a, 0x95, 0xa4, 0xc5, 0xb5, 0xaa, 0x28, 0xd3, 0x4b, 0x74, 0x1d, 0xcc, 0x1d, 0x13, 0xda, 0xa2, 0x41, 0x48, 0x5a, 0xf8, 0x8a, 0xb4, 0x5b, 0xf2, 0xc2, 0xcf, 0xa5, 0x86, 0x85, 0x2f, 0x2b, 0xd3, 0x60, 0x6d, 0x30, 0x7f, 0x4c, 0x28, 0x3b, 0x3f, 0x7f, 0xc4, 0x3d, 0x7a, 0xea, 0x5f, 0x05, 0xd2, 0xcd, 0x55, 0xd3, 0x14, 0x6f, 0xae, 0x05, 0x83, 0x24, 0xea, 0xe1, 0xe7, 0xff, 0xfc, 0xcb, 0x54, 0xe5, 0x6f, 0x1f, 0x37, 0x2b, 0xff, 0xf8, 0xb8, 0x59, 0xf9, 0xd7, 0xc7, 0xcd, 0xca, 0x9f, 0xff, 0xbd, 0xe9, 0x80, 0x85, 0x20, 0xbc, 0xe6, 0xcb, 0x68, 0xef, 0x36, 0xe6, 0xff, 0x8b, 0xe0, 0x72, 0x82, 0xff, 0xf9, 0xe2, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x80, 0x5c, 0x8a, 0x7a, 0xcd, 0x20, 0x00, 0x00, } kvproto-6.1.0-alpha/pkg/tracepb/000077500000000000000000000000001421456440000165065ustar00rootroot00000000000000kvproto-6.1.0-alpha/pkg/tracepb/tracepb.pb.go000066400000000000000000001510061421456440000210600ustar00rootroot00000000000000// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: tracepb.proto package tracepb import ( "fmt" "io" "math" proto "github.com/golang/protobuf/proto" context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // 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.ProtoPackageIsVersion2 // please upgrade the proto package type TraceRecordRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TraceRecordRequest) Reset() { *m = TraceRecordRequest{} } func (m *TraceRecordRequest) String() string { return proto.CompactTextString(m) } func (*TraceRecordRequest) ProtoMessage() {} func (*TraceRecordRequest) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{0} } func (m *TraceRecordRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TraceRecordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TraceRecordRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TraceRecordRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_TraceRecordRequest.Merge(dst, src) } func (m *TraceRecordRequest) XXX_Size() int { return m.Size() } func (m *TraceRecordRequest) XXX_DiscardUnknown() { xxx_messageInfo_TraceRecordRequest.DiscardUnknown(m) } var xxx_messageInfo_TraceRecordRequest proto.InternalMessageInfo type TraceRecord struct { // Types that are valid to be assigned to RecordOneof: // *TraceRecord_Report // *TraceRecord_NotifyCollect RecordOneof isTraceRecord_RecordOneof `protobuf_oneof:"record_oneof"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TraceRecord) Reset() { *m = TraceRecord{} } func (m *TraceRecord) String() string { return proto.CompactTextString(m) } func (*TraceRecord) ProtoMessage() {} func (*TraceRecord) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{1} } func (m *TraceRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TraceRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TraceRecord.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TraceRecord) XXX_Merge(src proto.Message) { xxx_messageInfo_TraceRecord.Merge(dst, src) } func (m *TraceRecord) XXX_Size() int { return m.Size() } func (m *TraceRecord) XXX_DiscardUnknown() { xxx_messageInfo_TraceRecord.DiscardUnknown(m) } var xxx_messageInfo_TraceRecord proto.InternalMessageInfo type isTraceRecord_RecordOneof interface { isTraceRecord_RecordOneof() MarshalTo([]byte) (int, error) Size() int } type TraceRecord_Report struct { Report *Report `protobuf:"bytes,1,opt,name=report,oneof"` } type TraceRecord_NotifyCollect struct { NotifyCollect *NotifyCollect `protobuf:"bytes,2,opt,name=notify_collect,json=notifyCollect,oneof"` } func (*TraceRecord_Report) isTraceRecord_RecordOneof() {} func (*TraceRecord_NotifyCollect) isTraceRecord_RecordOneof() {} func (m *TraceRecord) GetRecordOneof() isTraceRecord_RecordOneof { if m != nil { return m.RecordOneof } return nil } func (m *TraceRecord) GetReport() *Report { if x, ok := m.GetRecordOneof().(*TraceRecord_Report); ok { return x.Report } return nil } func (m *TraceRecord) GetNotifyCollect() *NotifyCollect { if x, ok := m.GetRecordOneof().(*TraceRecord_NotifyCollect); ok { return x.NotifyCollect } return nil } // XXX_OneofFuncs is for the internal use of the proto package. func (*TraceRecord) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _TraceRecord_OneofMarshaler, _TraceRecord_OneofUnmarshaler, _TraceRecord_OneofSizer, []interface{}{ (*TraceRecord_Report)(nil), (*TraceRecord_NotifyCollect)(nil), } } func _TraceRecord_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { m := msg.(*TraceRecord) // record_oneof switch x := m.RecordOneof.(type) { case *TraceRecord_Report: _ = b.EncodeVarint(1<<3 | proto.WireBytes) if err := b.EncodeMessage(x.Report); err != nil { return err } case *TraceRecord_NotifyCollect: _ = b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.NotifyCollect); err != nil { return err } case nil: default: return fmt.Errorf("TraceRecord.RecordOneof has unexpected type %T", x) } return nil } func _TraceRecord_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*TraceRecord) switch tag { case 1: // record_oneof.report if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(Report) err := b.DecodeMessage(msg) m.RecordOneof = &TraceRecord_Report{msg} return true, err case 2: // record_oneof.notify_collect if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType } msg := new(NotifyCollect) err := b.DecodeMessage(msg) m.RecordOneof = &TraceRecord_NotifyCollect{msg} return true, err default: return false, nil } } func _TraceRecord_OneofSizer(msg proto.Message) (n int) { m := msg.(*TraceRecord) // record_oneof switch x := m.RecordOneof.(type) { case *TraceRecord_Report: s := proto.Size(x.Report) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case *TraceRecord_NotifyCollect: s := proto.Size(x.NotifyCollect) n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) } return n } type RemoteParentSpan struct { // A unique id to identify the request. It's usually a UUID. TraceId uint64 `protobuf:"varint,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` // The span of remote caller that is awaiting the request. SpanId uint64 `protobuf:"varint,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoteParentSpan) Reset() { *m = RemoteParentSpan{} } func (m *RemoteParentSpan) String() string { return proto.CompactTextString(m) } func (*RemoteParentSpan) ProtoMessage() {} func (*RemoteParentSpan) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{2} } func (m *RemoteParentSpan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoteParentSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoteParentSpan.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *RemoteParentSpan) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoteParentSpan.Merge(dst, src) } func (m *RemoteParentSpan) XXX_Size() int { return m.Size() } func (m *RemoteParentSpan) XXX_DiscardUnknown() { xxx_messageInfo_RemoteParentSpan.DiscardUnknown(m) } var xxx_messageInfo_RemoteParentSpan proto.InternalMessageInfo func (m *RemoteParentSpan) GetTraceId() uint64 { if m != nil { return m.TraceId } return 0 } func (m *RemoteParentSpan) GetSpanId() uint64 { if m != nil { return m.SpanId } return 0 } // The context of the request to be traced. type TraceContext struct { RemoteParentSpans []*RemoteParentSpan `protobuf:"bytes,1,rep,name=remote_parent_spans,json=remoteParentSpans" json:"remote_parent_spans,omitempty"` // Report the trace records only if the duration of handling the request exceeds the threshold. DurationThresholdMs uint32 `protobuf:"varint,2,opt,name=duration_threshold_ms,json=durationThresholdMs,proto3" json:"duration_threshold_ms,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *TraceContext) Reset() { *m = TraceContext{} } func (m *TraceContext) String() string { return proto.CompactTextString(m) } func (*TraceContext) ProtoMessage() {} func (*TraceContext) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{3} } func (m *TraceContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *TraceContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_TraceContext.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *TraceContext) XXX_Merge(src proto.Message) { xxx_messageInfo_TraceContext.Merge(dst, src) } func (m *TraceContext) XXX_Size() int { return m.Size() } func (m *TraceContext) XXX_DiscardUnknown() { xxx_messageInfo_TraceContext.DiscardUnknown(m) } var xxx_messageInfo_TraceContext proto.InternalMessageInfo func (m *TraceContext) GetRemoteParentSpans() []*RemoteParentSpan { if m != nil { return m.RemoteParentSpans } return nil } func (m *TraceContext) GetDurationThresholdMs() uint32 { if m != nil { return m.DurationThresholdMs } return 0 } // Report the spans collected when handling a request on a service. type Report struct { RemoteParentSpans []*RemoteParentSpan `protobuf:"bytes,1,rep,name=remote_parent_spans,json=remoteParentSpans" json:"remote_parent_spans,omitempty"` Spans []*Span `protobuf:"bytes,2,rep,name=spans" json:"spans,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Report) Reset() { *m = Report{} } func (m *Report) String() string { return proto.CompactTextString(m) } func (*Report) ProtoMessage() {} func (*Report) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{4} } func (m *Report) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Report) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Report.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Report) XXX_Merge(src proto.Message) { xxx_messageInfo_Report.Merge(dst, src) } func (m *Report) XXX_Size() int { return m.Size() } func (m *Report) XXX_DiscardUnknown() { xxx_messageInfo_Report.DiscardUnknown(m) } var xxx_messageInfo_Report proto.InternalMessageInfo func (m *Report) GetRemoteParentSpans() []*RemoteParentSpan { if m != nil { return m.RemoteParentSpans } return nil } func (m *Report) GetSpans() []*Span { if m != nil { return m.Spans } return nil } // Notify the subscriber to persis the spans of the trace. type NotifyCollect struct { TraceId uint64 `protobuf:"varint,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NotifyCollect) Reset() { *m = NotifyCollect{} } func (m *NotifyCollect) String() string { return proto.CompactTextString(m) } func (*NotifyCollect) ProtoMessage() {} func (*NotifyCollect) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{5} } func (m *NotifyCollect) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NotifyCollect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NotifyCollect.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *NotifyCollect) XXX_Merge(src proto.Message) { xxx_messageInfo_NotifyCollect.Merge(dst, src) } func (m *NotifyCollect) XXX_Size() int { return m.Size() } func (m *NotifyCollect) XXX_DiscardUnknown() { xxx_messageInfo_NotifyCollect.DiscardUnknown(m) } var xxx_messageInfo_NotifyCollect proto.InternalMessageInfo func (m *NotifyCollect) GetTraceId() uint64 { if m != nil { return m.TraceId } return 0 } type Span struct { // The unique span id within the spans with the same `trace_id`. // The most significant 32 bits should be random number generated by each service instance. SpanId uint64 `protobuf:"varint,1,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"` ParentId uint64 `protobuf:"varint,2,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"` BeginUnixNs uint64 `protobuf:"varint,3,opt,name=begin_unix_ns,json=beginUnixNs,proto3" json:"begin_unix_ns,omitempty"` DurationNs uint64 `protobuf:"varint,4,opt,name=duration_ns,json=durationNs,proto3" json:"duration_ns,omitempty"` Event string `protobuf:"bytes,5,opt,name=event,proto3" json:"event,omitempty"` Properties []*Property `protobuf:"bytes,6,rep,name=properties" json:"properties,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Span) Reset() { *m = Span{} } func (m *Span) String() string { return proto.CompactTextString(m) } func (*Span) ProtoMessage() {} func (*Span) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{6} } func (m *Span) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Span) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Span.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Span) XXX_Merge(src proto.Message) { xxx_messageInfo_Span.Merge(dst, src) } func (m *Span) XXX_Size() int { return m.Size() } func (m *Span) XXX_DiscardUnknown() { xxx_messageInfo_Span.DiscardUnknown(m) } var xxx_messageInfo_Span proto.InternalMessageInfo func (m *Span) GetSpanId() uint64 { if m != nil { return m.SpanId } return 0 } func (m *Span) GetParentId() uint64 { if m != nil { return m.ParentId } return 0 } func (m *Span) GetBeginUnixNs() uint64 { if m != nil { return m.BeginUnixNs } return 0 } func (m *Span) GetDurationNs() uint64 { if m != nil { return m.DurationNs } return 0 } func (m *Span) GetEvent() string { if m != nil { return m.Event } return "" } func (m *Span) GetProperties() []*Property { if m != nil { return m.Properties } return nil } type Property struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Property) Reset() { *m = Property{} } func (m *Property) String() string { return proto.CompactTextString(m) } func (*Property) ProtoMessage() {} func (*Property) Descriptor() ([]byte, []int) { return fileDescriptor_tracepb_e95ec523a1669bb5, []int{7} } func (m *Property) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Property.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (dst *Property) XXX_Merge(src proto.Message) { xxx_messageInfo_Property.Merge(dst, src) } func (m *Property) XXX_Size() int { return m.Size() } func (m *Property) XXX_DiscardUnknown() { xxx_messageInfo_Property.DiscardUnknown(m) } var xxx_messageInfo_Property proto.InternalMessageInfo func (m *Property) GetKey() string { if m != nil { return m.Key } return "" } func (m *Property) GetValue() string { if m != nil { return m.Value } return "" } func init() { proto.RegisterType((*TraceRecordRequest)(nil), "tracepb.TraceRecordRequest") proto.RegisterType((*TraceRecord)(nil), "tracepb.TraceRecord") proto.RegisterType((*RemoteParentSpan)(nil), "tracepb.RemoteParentSpan") proto.RegisterType((*TraceContext)(nil), "tracepb.TraceContext") proto.RegisterType((*Report)(nil), "tracepb.Report") proto.RegisterType((*NotifyCollect)(nil), "tracepb.NotifyCollect") proto.RegisterType((*Span)(nil), "tracepb.Span") proto.RegisterType((*Property)(nil), "tracepb.Property") } // 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 // Client API for TraceRecordPubSub service type TraceRecordPubSubClient interface { // Subscribe the Trace records generated on this service. The service will periodically (e.g. per minute) // publishes Trace records to clients via gRPC stream. Subscribe(ctx context.Context, in *TraceRecordRequest, opts ...grpc.CallOption) (TraceRecordPubSub_SubscribeClient, error) } type traceRecordPubSubClient struct { cc *grpc.ClientConn } func NewTraceRecordPubSubClient(cc *grpc.ClientConn) TraceRecordPubSubClient { return &traceRecordPubSubClient{cc} } func (c *traceRecordPubSubClient) Subscribe(ctx context.Context, in *TraceRecordRequest, opts ...grpc.CallOption) (TraceRecordPubSub_SubscribeClient, error) { stream, err := c.cc.NewStream(ctx, &_TraceRecordPubSub_serviceDesc.Streams[0], "/tracepb.TraceRecordPubSub/Subscribe", opts...) if err != nil { return nil, err } x := &traceRecordPubSubSubscribeClient{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 TraceRecordPubSub_SubscribeClient interface { Recv() (*TraceRecord, error) grpc.ClientStream } type traceRecordPubSubSubscribeClient struct { grpc.ClientStream } func (x *traceRecordPubSubSubscribeClient) Recv() (*TraceRecord, error) { m := new(TraceRecord) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for TraceRecordPubSub service type TraceRecordPubSubServer interface { // Subscribe the Trace records generated on this service. The service will periodically (e.g. per minute) // publishes Trace records to clients via gRPC stream. Subscribe(*TraceRecordRequest, TraceRecordPubSub_SubscribeServer) error } func RegisterTraceRecordPubSubServer(s *grpc.Server, srv TraceRecordPubSubServer) { s.RegisterService(&_TraceRecordPubSub_serviceDesc, srv) } func _TraceRecordPubSub_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(TraceRecordRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(TraceRecordPubSubServer).Subscribe(m, &traceRecordPubSubSubscribeServer{stream}) } type TraceRecordPubSub_SubscribeServer interface { Send(*TraceRecord) error grpc.ServerStream } type traceRecordPubSubSubscribeServer struct { grpc.ServerStream } func (x *traceRecordPubSubSubscribeServer) Send(m *TraceRecord) error { return x.ServerStream.SendMsg(m) } var _TraceRecordPubSub_serviceDesc = grpc.ServiceDesc{ ServiceName: "tracepb.TraceRecordPubSub", HandlerType: (*TraceRecordPubSubServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "Subscribe", Handler: _TraceRecordPubSub_Subscribe_Handler, ServerStreams: true, }, }, Metadata: "tracepb.proto", } func (m *TraceRecordRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TraceRecordRequest) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TraceRecord) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TraceRecord) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.RecordOneof != nil { nn1, err := m.RecordOneof.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += nn1 } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TraceRecord_Report) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.Report != nil { dAtA[i] = 0xa i++ i = encodeVarintTracepb(dAtA, i, uint64(m.Report.Size())) n2, err := m.Report.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } return i, nil } func (m *TraceRecord_NotifyCollect) MarshalTo(dAtA []byte) (int, error) { i := 0 if m.NotifyCollect != nil { dAtA[i] = 0x12 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.NotifyCollect.Size())) n3, err := m.NotifyCollect.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } return i, nil } func (m *RemoteParentSpan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RemoteParentSpan) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TraceId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.TraceId)) } if m.SpanId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.SpanId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *TraceContext) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *TraceContext) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.RemoteParentSpans) > 0 { for _, msg := range m.RemoteParentSpans { dAtA[i] = 0xa i++ i = encodeVarintTracepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.DurationThresholdMs != 0 { dAtA[i] = 0x10 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.DurationThresholdMs)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Report) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Report) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.RemoteParentSpans) > 0 { for _, msg := range m.RemoteParentSpans { dAtA[i] = 0xa i++ i = encodeVarintTracepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if len(m.Spans) > 0 { for _, msg := range m.Spans { dAtA[i] = 0x12 i++ i = encodeVarintTracepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *NotifyCollect) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *NotifyCollect) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.TraceId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.TraceId)) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Span) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Span) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if m.SpanId != 0 { dAtA[i] = 0x8 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.SpanId)) } if m.ParentId != 0 { dAtA[i] = 0x10 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.ParentId)) } if m.BeginUnixNs != 0 { dAtA[i] = 0x18 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.BeginUnixNs)) } if m.DurationNs != 0 { dAtA[i] = 0x20 i++ i = encodeVarintTracepb(dAtA, i, uint64(m.DurationNs)) } if len(m.Event) > 0 { dAtA[i] = 0x2a i++ i = encodeVarintTracepb(dAtA, i, uint64(len(m.Event))) i += copy(dAtA[i:], m.Event) } if len(m.Properties) > 0 { for _, msg := range m.Properties { dAtA[i] = 0x32 i++ i = encodeVarintTracepb(dAtA, i, uint64(msg.Size())) n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n } } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func (m *Property) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Property) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l if len(m.Key) > 0 { dAtA[i] = 0xa i++ i = encodeVarintTracepb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } if len(m.Value) > 0 { dAtA[i] = 0x12 i++ i = encodeVarintTracepb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } return i, nil } func encodeVarintTracepb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return offset + 1 } func (m *TraceRecordRequest) Size() (n int) { var l int _ = l if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TraceRecord) Size() (n int) { var l int _ = l if m.RecordOneof != nil { n += m.RecordOneof.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TraceRecord_Report) Size() (n int) { var l int _ = l if m.Report != nil { l = m.Report.Size() n += 1 + l + sovTracepb(uint64(l)) } return n } func (m *TraceRecord_NotifyCollect) Size() (n int) { var l int _ = l if m.NotifyCollect != nil { l = m.NotifyCollect.Size() n += 1 + l + sovTracepb(uint64(l)) } return n } func (m *RemoteParentSpan) Size() (n int) { var l int _ = l if m.TraceId != 0 { n += 1 + sovTracepb(uint64(m.TraceId)) } if m.SpanId != 0 { n += 1 + sovTracepb(uint64(m.SpanId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *TraceContext) Size() (n int) { var l int _ = l if len(m.RemoteParentSpans) > 0 { for _, e := range m.RemoteParentSpans { l = e.Size() n += 1 + l + sovTracepb(uint64(l)) } } if m.DurationThresholdMs != 0 { n += 1 + sovTracepb(uint64(m.DurationThresholdMs)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Report) Size() (n int) { var l int _ = l if len(m.RemoteParentSpans) > 0 { for _, e := range m.RemoteParentSpans { l = e.Size() n += 1 + l + sovTracepb(uint64(l)) } } if len(m.Spans) > 0 { for _, e := range m.Spans { l = e.Size() n += 1 + l + sovTracepb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *NotifyCollect) Size() (n int) { var l int _ = l if m.TraceId != 0 { n += 1 + sovTracepb(uint64(m.TraceId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Span) Size() (n int) { var l int _ = l if m.SpanId != 0 { n += 1 + sovTracepb(uint64(m.SpanId)) } if m.ParentId != 0 { n += 1 + sovTracepb(uint64(m.ParentId)) } if m.BeginUnixNs != 0 { n += 1 + sovTracepb(uint64(m.BeginUnixNs)) } if m.DurationNs != 0 { n += 1 + sovTracepb(uint64(m.DurationNs)) } l = len(m.Event) if l > 0 { n += 1 + l + sovTracepb(uint64(l)) } if len(m.Properties) > 0 { for _, e := range m.Properties { l = e.Size() n += 1 + l + sovTracepb(uint64(l)) } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *Property) Size() (n int) { var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovTracepb(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovTracepb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTracepb(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozTracepb(x uint64) (n int) { return sovTracepb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *TraceRecordRequest) 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 ErrIntOverflowTracepb } 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: TraceRecordRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TraceRecordRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *TraceRecord) 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 ErrIntOverflowTracepb } 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: TraceRecord: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TraceRecord: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Report", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &Report{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.RecordOneof = &TraceRecord_Report{v} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NotifyCollect", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } v := &NotifyCollect{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } m.RecordOneof = &TraceRecord_NotifyCollect{v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *RemoteParentSpan) 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 ErrIntOverflowTracepb } 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: RemoteParentSpan: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoteParentSpan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType) } m.TraceId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TraceId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SpanId", wireType) } m.SpanId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SpanId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *TraceContext) 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 ErrIntOverflowTracepb } 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: TraceContext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: TraceContext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RemoteParentSpans", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RemoteParentSpans = append(m.RemoteParentSpans, &RemoteParentSpan{}) if err := m.RemoteParentSpans[len(m.RemoteParentSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DurationThresholdMs", wireType) } m.DurationThresholdMs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DurationThresholdMs |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *Report) 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 ErrIntOverflowTracepb } 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: Report: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Report: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RemoteParentSpans", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.RemoteParentSpans = append(m.RemoteParentSpans, &RemoteParentSpan{}) if err := m.RemoteParentSpans[len(m.RemoteParentSpans)-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 Spans", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Spans = append(m.Spans, &Span{}) if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *NotifyCollect) 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 ErrIntOverflowTracepb } 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: NotifyCollect: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NotifyCollect: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType) } m.TraceId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.TraceId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *Span) 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 ErrIntOverflowTracepb } 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: Span: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Span: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SpanId", wireType) } m.SpanId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.SpanId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ParentId", wireType) } m.ParentId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ParentId |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field BeginUnixNs", wireType) } m.BeginUnixNs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.BeginUnixNs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field DurationNs", wireType) } m.DurationNs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.DurationNs |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } 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 ErrInvalidLengthTracepb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Event = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return ErrInvalidLengthTracepb } postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } m.Properties = append(m.Properties, &Property{}) if err := m.Properties[len(m.Properties)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 *Property) 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 ErrIntOverflowTracepb } 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: Property: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Property: 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 ErrIntOverflowTracepb } 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 ErrInvalidLengthTracepb } postIndex := iNdEx + intStringLen 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 Value", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTracepb } 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 ErrInvalidLengthTracepb } postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } m.Value = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTracepb(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTracepb } 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 skipTracepb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTracepb } 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, ErrIntOverflowTracepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTracepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } iNdEx += length if length < 0 { return 0, ErrInvalidLengthTracepb } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTracepb } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ innerWire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } innerWireType := int(innerWire & 0x7) if innerWireType == 4 { break } next, err := skipTracepb(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthTracepb = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTracepb = fmt.Errorf("proto: integer overflow") ) func init() { proto.RegisterFile("tracepb.proto", fileDescriptor_tracepb_e95ec523a1669bb5) } var fileDescriptor_tracepb_e95ec523a1669bb5 = []byte{ // 511 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xcb, 0x6e, 0xd3, 0x40, 0x14, 0xcd, 0xe4, 0xd5, 0xe4, 0xa6, 0x2e, 0xc9, 0x34, 0x80, 0x4b, 0xa5, 0x10, 0x0d, 0x9b, 0xc0, 0x22, 0x82, 0xf0, 0x01, 0x48, 0xa9, 0x84, 0x9a, 0x05, 0x51, 0x34, 0x29, 0x62, 0x69, 0xd9, 0xf1, 0xb4, 0xb5, 0x92, 0xce, 0x98, 0x99, 0x71, 0x94, 0x7c, 0x02, 0x0b, 0xf6, 0x7c, 0x12, 0x62, 0xc5, 0x27, 0xa0, 0xf0, 0x23, 0xc8, 0xd7, 0x89, 0xe5, 0x02, 0x62, 0xc5, 0xca, 0x73, 0xcf, 0xb9, 0xaf, 0x73, 0xac, 0x0b, 0x8e, 0xd5, 0xfe, 0x42, 0xc4, 0xc1, 0x30, 0xd6, 0xca, 0x2a, 0x7a, 0xb4, 0x0f, 0x59, 0x17, 0xe8, 0x55, 0xfa, 0xe4, 0x62, 0xa1, 0x74, 0xc8, 0xc5, 0xc7, 0x44, 0x18, 0xcb, 0x3e, 0x11, 0x68, 0x15, 0x60, 0xfa, 0x1c, 0xea, 0x5a, 0xc4, 0x4a, 0x5b, 0x97, 0xf4, 0xc9, 0xa0, 0x35, 0x7a, 0x30, 0x3c, 0xb4, 0xe3, 0x08, 0x5f, 0x96, 0xf8, 0x3e, 0x81, 0xbe, 0x81, 0x13, 0xa9, 0x6c, 0x74, 0xbd, 0xf5, 0x16, 0x6a, 0xb5, 0x12, 0x0b, 0xeb, 0x96, 0xb1, 0xe4, 0x51, 0x5e, 0x32, 0x45, 0xfa, 0x22, 0x63, 0x2f, 0x4b, 0xdc, 0x91, 0x45, 0x60, 0x7c, 0x02, 0xc7, 0x1a, 0xa7, 0x7a, 0x4a, 0x0a, 0x75, 0xcd, 0xde, 0x42, 0x9b, 0x8b, 0x3b, 0x65, 0xc5, 0xcc, 0xd7, 0x42, 0xda, 0x79, 0xec, 0x4b, 0x7a, 0x06, 0x0d, 0xec, 0xe6, 0x45, 0x21, 0x6e, 0x54, 0xe5, 0x99, 0xa0, 0x49, 0x48, 0x1f, 0xc3, 0x91, 0x89, 0x7d, 0x99, 0x32, 0x65, 0x64, 0xea, 0x69, 0x38, 0x09, 0xd9, 0x67, 0x02, 0xc7, 0xa8, 0xe9, 0x42, 0x49, 0x2b, 0x36, 0x96, 0x4e, 0xe0, 0x54, 0x63, 0x63, 0x2f, 0xc6, 0xce, 0x5e, 0x9a, 0x68, 0x5c, 0xd2, 0xaf, 0x0c, 0x5a, 0xa3, 0xb3, 0x82, 0xc2, 0xfb, 0xc3, 0x79, 0x47, 0xff, 0x86, 0x18, 0x3a, 0x82, 0x87, 0x61, 0xa2, 0x7d, 0x1b, 0x29, 0xe9, 0xd9, 0x5b, 0x2d, 0xcc, 0xad, 0x5a, 0x85, 0xde, 0x9d, 0xc1, 0x15, 0x1c, 0x7e, 0x7a, 0x20, 0xaf, 0x0e, 0xdc, 0x3b, 0xc3, 0x36, 0x50, 0xcf, 0xcc, 0xfb, 0x9f, 0x8b, 0x3c, 0x83, 0x5a, 0x56, 0x5c, 0xc6, 0x62, 0x27, 0x2f, 0xc6, 0x82, 0x8c, 0x63, 0x2f, 0xc0, 0xb9, 0xf7, 0x0f, 0xfe, 0x61, 0x27, 0xfb, 0x46, 0xa0, 0x8a, 0x96, 0x17, 0x7c, 0x25, 0x45, 0x5f, 0xe9, 0x39, 0x34, 0xf7, 0x6b, 0xe7, 0x96, 0x37, 0x32, 0x60, 0x12, 0x52, 0x06, 0x4e, 0x20, 0x6e, 0x22, 0xe9, 0x25, 0x32, 0xda, 0x78, 0xd2, 0xb8, 0x15, 0x4c, 0x68, 0x21, 0xf8, 0x5e, 0x46, 0x9b, 0xa9, 0xa1, 0x4f, 0xa1, 0x95, 0x9b, 0x27, 0x8d, 0x5b, 0xc5, 0x0c, 0x38, 0x40, 0x53, 0x43, 0xbb, 0x50, 0x13, 0x6b, 0x21, 0xad, 0x5b, 0xeb, 0x93, 0x41, 0x93, 0x67, 0x01, 0x7d, 0x05, 0x10, 0x6b, 0x15, 0x0b, 0x6d, 0x23, 0x61, 0xdc, 0x3a, 0xea, 0xed, 0xe4, 0x7a, 0x67, 0x19, 0xb5, 0xe5, 0x85, 0x24, 0x36, 0x82, 0xc6, 0x01, 0xa7, 0x6d, 0xa8, 0x2c, 0xc5, 0x16, 0xb5, 0x34, 0x79, 0xfa, 0x4c, 0xc7, 0xac, 0xfd, 0x55, 0x22, 0x50, 0x44, 0x93, 0x67, 0xc1, 0xe8, 0x03, 0x74, 0x0a, 0x97, 0x30, 0x4b, 0x82, 0x79, 0x12, 0xd0, 0x31, 0x34, 0xe7, 0x49, 0x60, 0x16, 0x3a, 0x0a, 0x04, 0x3d, 0xcf, 0x87, 0xfe, 0x79, 0x49, 0x4f, 0xba, 0x7f, 0x23, 0x59, 0xe9, 0x25, 0x19, 0xb3, 0xaf, 0xbb, 0x1e, 0xf9, 0xbe, 0xeb, 0x91, 0x1f, 0xbb, 0x1e, 0xf9, 0xf2, 0xb3, 0x57, 0x82, 0xb6, 0xd2, 0x37, 0x43, 0x1b, 0x2d, 0xd7, 0xc3, 0xe5, 0x1a, 0xcf, 0x34, 0xa8, 0xe3, 0xe7, 0xf5, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x52, 0x50, 0x65, 0xbd, 0xbe, 0x03, 0x00, 0x00, } kvproto-6.1.0-alpha/proto/000077500000000000000000000000001421456440000154505ustar00rootroot00000000000000kvproto-6.1.0-alpha/proto/brpb.proto000066400000000000000000000232111421456440000174610ustar00rootroot00000000000000syntax = "proto3"; package backup; import "kvrpcpb.proto"; import "errorpb.proto"; import "encryptionpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // The message save the metadata of a backup. message BackupMeta { // ID and version of backuped cluster. uint64 cluster_id = 1; string cluster_version = 2; // Save the version of BR running backup jobs. string br_version = 11; // The backupmeta scheme version. int32 version = 12; // path field is no longer used. reserved 3; reserved "path"; // A set of files that compose a backup. // Note: `files` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. repeated File files = 4; // An index to files contains data files. MetaFile file_index = 13; // A pair of timestamp specifies a time range of a backup. // For full backup, the start_version equals to the end_version, // it means point in time. // For incremental backup, the time range is specified as // (start_version, end_version]. uint64 start_version = 5; uint64 end_version = 6; // Table metadata describes database and table info. // Note: `schemas` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. repeated Schema schemas = 7; // An index to files contains Schemas. MetaFile schema_index = 14; // If in raw kv mode, `start_versions`, `end_versions` and `schemas` will be // ignored, and the backup data's range is represented by raw_ranges. bool is_raw_kv = 8; // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. repeated RawRange raw_ranges = 9; // An index to files contains RawRanges. MetaFile raw_range_index = 15; // In incremental backup, DDLs which are completed in // (lastBackupTS, backupTS] will be stored here. // Note: `raw_ranges` is deprecated, as it bloats backupmeta. It is kept for // compatibility, so new BR can restore older backups. bytes ddls = 10; // An index to files contains DDLs. MetaFile ddl_indexes = 16; // the backup result into `backupmeta` file string backup_result = 17; // API version implies the encode of the key and value. kvrpcpb.APIVersion api_version = 18; // the placement policy info in backup cluster. we assume the policy won't be too much for one cluster. repeated PlacementPolicy policies = 19; } message File { string name = 1; bytes sha256 = 2; bytes start_key = 3; bytes end_key = 4; uint64 start_version = 5; uint64 end_version = 6; uint64 crc64xor = 7; uint64 total_kvs = 8; uint64 total_bytes = 9; string cf = 10; uint64 size = 11; // cipher_iv is used for AES cipher bytes cipher_iv = 12; } // MetaFile describes a multi-level index of data used in backup. message MetaFile { // A set of files that contains a MetaFile. // It is used as a multi-level index. repeated File meta_files = 1; // A set of files that contains user data. repeated File data_files = 2; // A set of files that contains Schemas. repeated Schema schemas = 3; // A set of files that contains RawRanges. repeated RawRange raw_ranges = 4; // A set of files that contains DDLs. repeated bytes ddls = 5; } message PlacementPolicy { bytes info = 1; } message Schema { bytes db = 1; bytes table = 2; uint64 crc64xor = 3; uint64 total_kvs = 4; uint64 total_bytes = 5; uint32 tiflash_replicas = 6; // stats represents the dump stats for a analyzed table, which generate by DumpStatsToJSON // https://github.com/pingcap/tidb/blob/e136429d8dc5d70f43cd3f94179b0b9f47595097/statistics/handle/dump.go#L116 bytes stats = 7; } message RawRange { bytes start_key = 1; bytes end_key = 2; string cf = 3; } message ClusterIDError { uint64 current = 1; uint64 request = 2; } message Error { string msg = 1; oneof detail { ClusterIDError cluster_id_error = 3; kvrpcpb.KeyError kv_error = 4; errorpb.Error region_error = 5; } } // sst files compression algorithm enum CompressionType { UNKNOWN = 0; LZ4 = 1; SNAPPY = 2; ZSTD = 3; } message CipherInfo { encryptionpb.EncryptionMethod cipher_type = 1; bytes cipher_key = 2; } message BackupRequest { uint64 cluster_id = 1; bytes start_key = 2; bytes end_key = 3; uint64 start_version = 4; uint64 end_version = 5; // path field is deprecated, use storage_backend instead reserved 6; reserved "path"; // The I/O rate limit for backup request. uint64 rate_limit = 7; // The concurrency for executing the backup request in every tikv node. uint32 concurrency = 8; StorageBackend storage_backend = 9; // If raw kv mode is enabled, `start_version` and `end_version` will be ignored, and `cf` // specifies which cf to backup. bool is_raw_kv = 10; string cf = 11; // algorithm used for compress sst files CompressionType compression_type = 12; // sst compression level, some algorithms support negative compression levels int32 compression_level = 13; // The cipher_info is Used to encrypt sst CipherInfo cipher_info = 14; } message StorageBackend { oneof backend { Noop noop = 1; Local local = 2; S3 s3 = 3; GCS gcs = 4; CloudDynamic cloud_dynamic = 5; HDFS hdfs = 6; AzureBlobStorage azure_blob_storage = 7; } } // Noop storage backend saves files into void. message Noop {} // Local storage backend saves files into local disk message Local { string path = 1; } // S3 storage backend saves files into S3 compatible storages // For non-aws providers, endpoint must be provided message S3 { string endpoint = 1; string region = 2; string bucket = 3; string prefix = 4; string storage_class = 5; // server side encryption string sse = 6; string acl = 7; string access_key = 8; string secret_access_key = 9; bool force_path_style = 10; string sse_kms_key_id = 11; } // GCS storage backend saves files into google cloud storage. message GCS { string endpoint = 1; string bucket = 2; string prefix = 3; string storage_class = 4; // If not empty, applies a predefined set of access controls. // See https://cloud.google.com/storage/docs/access-control/lists#predefined-acl // for valid values. string predefined_acl = 5; // Service Account Credentials JSON blob // You can get one from https://console.cloud.google.com/apis/credentials, and // copy the content, set it as string here. string credentials_blob = 6; } // AzureBlobStorage storage backend saves files into azure blob storage. message AzureBlobStorage { string endpoint = 1; // Alias: container string bucket = 2; // Notice: prefix starts without `/`, otherwise the first directory's name is empty. string prefix = 3; // Alias: access_tier. // See https://docs.microsoft.com/en-us/azure/storage/blobs/access-tiers-overview string storage_class = 4; // if empty, try to read account_name from the node's environment variable $AZURE_STORAGE_ACCOUNT. string account_name = 5; // Use shared key to access the azure blob // If the node's environment variables($AZURE_CLIENT_ID, $AZURE_TENANT_ID, $AZURE_CLIENT_SECRET) exist, // prefer to use token to access the azure blob. // // See https://docs.microsoft.com/en-us/azure/storage/common/identity-library-acquire-token?toc=/azure/storage/blobs/toc.json // // Otherwise, if empty, try to read shared key from the node's environment variable $AZURE_STORAGE_KEY. string shared_key = 6; } message Bucket { string endpoint = 1; string region = 3; string bucket = 4; string prefix = 5; string storage_class = 6; } // CloudDynamic allows testing new cloud providers and new fields without changing protobuf definitions message CloudDynamic { Bucket bucket = 1; string provider_name = 2; // s3, gcs and azureBlobStorage are supported map attrs = 3; } // HDFS storage backend saves file into HDFS compatible storages message HDFS { // a URL: hdfs:///some/path or hdfs://host:port/some/path string remote = 1; } message BackupResponse { Error error = 1; bytes start_key = 2; bytes end_key = 3; repeated File files = 4; // API version implies the encode of the key and value. kvrpcpb.APIVersion api_version = 5; } service Backup { rpc backup(BackupRequest) returns (stream BackupResponse) {} } // ExternalStorage is a service for using a cloud backend from StorageBackend to store files. // This can be used to backup and restore SST files. service ExternalStorage { // Restore to a file rpc restore(ExternalStorageRestoreRequest) returns (ExternalStorageRestoreResponse) {} // Save a file to storage rpc save(ExternalStorageSaveRequest) returns (ExternalStorageSaveResponse) {} } message ExternalStorageRestoreRequest { StorageBackend storage_backend = 1; string object_name = 2; string restore_name = 3; uint64 content_length = 4; } message ExternalStorageRestoreResponse { } message ExternalStorageSaveRequest { StorageBackend storage_backend = 1; string object_name = 2; uint64 content_length = 3; } message ExternalStorageSaveResponse { } kvproto-6.1.0-alpha/proto/cdcpb.proto000066400000000000000000000073641421456440000176220ustar00rootroot00000000000000syntax = "proto3"; package cdcpb; import "raft_cmdpb.proto"; import "metapb.proto"; import "errorpb.proto"; import "kvrpcpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option(gogoproto.sizer_all) = true; option(gogoproto.marshaler_all) = true; option(gogoproto.unmarshaler_all) = true; option(rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; message Header { uint64 cluster_id = 1; string ticdc_version = 2; } message DuplicateRequest { uint64 region_id = 1; } message Compatibility { string required_version = 1; } // ClusterIDMismatch is an error variable that // tells people that the cluster ID of the request does not match the TiKV cluster ID. message ClusterIDMismatch { // The current tikv cluster ID. uint64 current = 1; // The cluster ID of the TiCDC request. uint64 request = 2; } message Error { errorpb.NotLeader not_leader = 1; errorpb.RegionNotFound region_not_found = 2; errorpb.EpochNotMatch epoch_not_match = 3; DuplicateRequest duplicate_request = 4; Compatibility compatibility = 5; ClusterIDMismatch cluster_id_mismatch = 6; } message TxnInfo { uint64 start_ts = 1; bytes primary = 2; } message TxnStatus { uint64 start_ts = 1; uint64 min_commit_ts = 2; uint64 commit_ts = 3; bool is_rolled_back = 4; } message Event { enum LogType { UNKNOWN = 0; PREWRITE = 1; COMMIT = 2; ROLLBACK = 3; COMMITTED = 4; INITIALIZED = 5; } message Row { uint64 start_ts = 1; uint64 commit_ts = 2; LogType type = 3; enum OpType { UNKNOWN = 0; PUT = 1; DELETE = 2; } OpType op_type = 4; bytes key = 5; bytes value = 6; bytes old_value = 7; } message Entries { repeated Row entries = 1; } message Admin { raft_cmdpb.AdminRequest admin_request = 1; raft_cmdpb.AdminResponse admin_response = 2; } message LongTxn { repeated TxnInfo txn_info = 1; } uint64 region_id = 1; uint64 index = 2; uint64 request_id = 7; oneof event { Entries entries = 3; Admin admin = 4; Error error = 5; uint64 resolved_ts = 6 [deprecated=true]; // Note that field 7 is taken by request_id. LongTxn long_txn = 8; // More region level events ... } } message ChangeDataEvent { repeated Event events = 1; ResolvedTs resolved_ts = 2; // More store level events ... } message ResolvedTs { repeated uint64 regions = 1; uint64 ts = 2; } message ChangeDataRequest { message Register {} message NotifyTxnStatus { repeated TxnStatus txn_status = 1; } Header header = 1; uint64 region_id = 2; metapb.RegionEpoch region_epoch = 3; uint64 checkpoint_ts = 4; bytes start_key = 5; bytes end_key = 6; // Used for CDC to identify events corresponding to different requests. uint64 request_id = 7; kvrpcpb.ExtraOp extra_op = 8; oneof request { // A normal request that trying to register change data feed on a region. Register register = 9; // Notify the region that some of the running transactions on the region has a pushed // min_commit_ts so that the resolved_ts can be advanced. NotifyTxnStatus notify_txn_status = 10; } // KvAPI specifies to capture data written by different KV API. // See more details in https://github.com/tikv/rfcs/blob/master/text/0069-api-v2.md. enum KvAPI { TiBD = 0; RawKV = 1; TxnKV = 2; } KvAPI kv_api = 11; } service ChangeData { rpc EventFeed(stream ChangeDataRequest) returns(stream ChangeDataEvent); } kvproto-6.1.0-alpha/proto/configpb.proto000066400000000000000000000060251421456440000203270ustar00rootroot00000000000000syntax = "proto3"; package configpb; import "gogoproto/gogo.proto"; import "rustproto.proto"; import "google/api/annotations.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; service Config { rpc Create(CreateRequest) returns (CreateResponse) {} rpc GetAll(GetAllRequest) returns (GetAllResponse) {} rpc Get(GetRequest) returns (GetResponse) { option (google.api.http) = { get: "/component" }; } rpc Update(UpdateRequest) returns (UpdateResponse) { option (google.api.http) = { post: "/component" body: "*" }; } rpc Delete(DeleteRequest) returns (DeleteResponse) { option (google.api.http) = { delete: "/component" }; } } enum StatusCode { UNKNOWN = 0; OK = 1; WRONG_VERSION = 2; NOT_CHANGE = 3; COMPONENT_NOT_FOUND = 4; COMPONENT_ID_NOT_FOUND = 5; } message Status { StatusCode code = 1; string message = 2; } // The version is used to tell the configuration which can be shared // or not apart. // Global version represents the version of these configuration // which can be shared, each kind of component only have one. // For local version, every component will have one to represent // the version of these configuration which cannot be shared. message Version { uint64 local = 1; uint64 global = 2; } message Local { string component_id = 1; } message Global { string component = 1; } message ConfigKind { oneof kind { Local local = 1; Global global = 2; } } message ConfigEntry { string name = 1; string value = 2; } message LocalConfig { Version version = 1; string component = 2; string component_id = 3; string config = 4; } message Header { uint64 cluster_id = 1; } message CreateRequest { Header header = 1; Version version = 2; string component = 3; string component_id = 4; string config = 5; } message CreateResponse { Header header = 1; Status status = 2; Version version = 3; string config = 4; } message GetAllRequest { Header header = 1; } message GetAllResponse { Header header = 1; Status status = 2; repeated LocalConfig local_configs = 3; } message GetRequest { Header header = 1; Version version = 2; string component = 3; string component_id = 4; } message GetResponse { Header header = 1; Status status = 2; Version version = 3; string config = 4; } message UpdateRequest { Header header = 1; Version version = 2; ConfigKind kind = 3; repeated ConfigEntry entries = 4; } message UpdateResponse { Header header = 1; Status status = 2; Version version = 3; string config = 4; } message DeleteRequest { Header header = 1; Version version = 2; ConfigKind kind = 3; } message DeleteResponse { Header header = 1; Status status = 2; Version version = 3; } kvproto-6.1.0-alpha/proto/coprocessor.proto000066400000000000000000000053431421456440000211030ustar00rootroot00000000000000syntax = "proto3"; package coprocessor; import "errorpb.proto"; import "kvrpcpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; import "metapb.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // [start, end) message KeyRange { bytes start = 1; bytes end = 2; } message Request { kvrpcpb.Context context = 1; int64 tp = 2; bytes data = 3; uint64 start_ts = 7; repeated KeyRange ranges = 4; // If cache is enabled, TiKV returns cache hit instead of data if // its last version matches this `cache_if_match_version`. bool is_cache_enabled = 5; uint64 cache_if_match_version = 6; // Any schema-ful storage to validate schema correctness if necessary. int64 schema_ver = 8; bool is_trace_enabled = 9; // paging_size is 0 when it's disabled, otherwise, it should be a positive number. uint64 paging_size = 10; } message Response { bytes data = 1 [(gogoproto.customtype) = "github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes", (gogoproto.nullable) = false]; errorpb.Error region_error = 2; kvrpcpb.LockInfo locked = 3; string other_error = 4; KeyRange range = 5; // This field is always filled for compatibility consideration. However // newer TiDB should respect `exec_details_v2` field instead. kvrpcpb.ExecDetails exec_details = 6; // This field is provided in later versions, containing more detailed // information. kvrpcpb.ExecDetailsV2 exec_details_v2 = 11; bool is_cache_hit = 7; uint64 cache_last_version = 8; bool can_be_cached = 9; reserved 10; // Contains the latest buckets version of the region. // Clients should query PD to update buckets in cache if its is stale. uint64 latest_buckets_version = 12; } message RegionInfo { uint64 region_id = 1; metapb.RegionEpoch region_epoch = 2; repeated KeyRange ranges = 3; } message TableRegions { int64 physical_table_id = 1; repeated RegionInfo regions = 2; } message BatchRequest { kvrpcpb.Context context = 1; int64 tp = 2; bytes data = 3; repeated RegionInfo regions = 4; uint64 start_ts = 5; // Any schema-ful storage to validate schema correctness if necessary. int64 schema_ver = 6; // Used for partition table scan repeated TableRegions table_regions = 7; } message BatchResponse { bytes data = 1 [(gogoproto.customtype) = "github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes", (gogoproto.nullable) = false]; string other_error = 2; kvrpcpb.ExecDetails exec_details = 3; repeated metapb.Region retry_regions = 4; } kvproto-6.1.0-alpha/proto/deadlock.proto000066400000000000000000000035711421456440000203110ustar00rootroot00000000000000syntax = "proto3"; package deadlock; import "gogoproto/gogo.proto"; message WaitForEntriesRequest { } message WaitForEntriesResponse { repeated WaitForEntry entries = 1 [(gogoproto.nullable) = false]; } message WaitForEntry { // The transaction id that is waiting. uint64 txn = 1; // The transaction id that is being waited for. uint64 wait_for_txn = 2; // The hash value of the key is being waited for. uint64 key_hash = 3; // The key the current txn is trying to lock. bytes key = 4; // The tag came from the lock request's context. bytes resource_group_tag = 5; // Milliseconds it has been waits. uint64 wait_time = 6; } enum DeadlockRequestType { Detect = 0; // CleanUpWaitFor cleans a single entry the transaction is waiting. CleanUpWaitFor = 1; // CleanUp cleans all entries the transaction is waiting. CleanUp = 2; } message DeadlockRequest { DeadlockRequestType tp = 1; WaitForEntry entry = 2 [(gogoproto.nullable) = false]; } message DeadlockResponse { // The same entry sent by DeadlockRequest, identifies the sender. WaitForEntry entry = 1 [(gogoproto.nullable) = false]; // The key hash of the lock that is hold by the waiting transaction. uint64 deadlock_key_hash = 2; // The other entries of the dead lock circle. The current entry is in `entry` field and not // included in this field. repeated WaitForEntry wait_chain = 3; } service Deadlock { // Get local wait for entries, should be handle by every node. // The owner should sent this request to all members to build the complete wait for graph. rpc GetWaitForEntries(WaitForEntriesRequest) returns (WaitForEntriesResponse) {} // Detect should only sent to the owner. only be handled by the owner. // The DeadlockResponse is sent back only if there is deadlock detected. // CleanUpWaitFor and CleanUp doesn't return responses. rpc Detect(stream DeadlockRequest) returns (stream DeadlockResponse) {} } kvproto-6.1.0-alpha/proto/debugpb.proto000066400000000000000000000141101421456440000201420ustar00rootroot00000000000000syntax = "proto3"; package debugpb; import "eraftpb.proto"; import "kvrpcpb.proto"; import "raft_serverpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // Debug service for TiKV. // // Errors are defined as follow: // - OK: Okay, we are good! // - UNKNOWN: For unknown error. // - INVALID_ARGUMENT: Something goes wrong within requests. // - NOT_FOUND: It is key or region not found, it's based on context, detailed // reason can be found in grpc message. // Note: It bypasses raft layer. service Debug { // Read a value arbitrarily for a key. // Note: Server uses key directly w/o any encoding. rpc Get(GetRequest) returns (GetResponse) {} // Read raft info. rpc RaftLog(RaftLogRequest) returns (RaftLogResponse) {} rpc RegionInfo(RegionInfoRequest) returns (RegionInfoResponse) {} // Calculate size of a region. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. rpc RegionSize(RegionSizeRequest) returns (RegionSizeResponse) {} // Scan a specific range. // Note: DO NOT CALL IT IN PRODUCTION, it's really expensive. // Server uses keys directly w/o any encoding. rpc ScanMvcc(ScanMvccRequest) returns (stream ScanMvccResponse) {} // Compact a column family in a specified range. // Note: Server uses keys directly w/o any encoding. rpc Compact(CompactRequest) returns (CompactResponse) {} // Inject a fail point. Currently, it's only used in tests. // Note: DO NOT CALL IT IN PRODUCTION. rpc InjectFailPoint(InjectFailPointRequest) returns (InjectFailPointResponse) {} // Recover from a fail point. rpc RecoverFailPoint(RecoverFailPointRequest) returns (RecoverFailPointResponse) {} // List all fail points. rpc ListFailPoints(ListFailPointsRequest) returns (ListFailPointsResponse) {} // Get Metrics rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse){} // Do a consistent check for a region. rpc CheckRegionConsistency(RegionConsistencyCheckRequest) returns (RegionConsistencyCheckResponse) {} // dynamically modify tikv's config rpc ModifyTikvConfig(ModifyTikvConfigRequest) returns (ModifyTikvConfigResponse) {} // Get region properties rpc GetRegionProperties(GetRegionPropertiesRequest) returns (GetRegionPropertiesResponse) {} // Get store ID rpc GetStoreInfo(GetStoreInfoRequest) returns (GetStoreInfoResponse) {} // Get cluster ID rpc GetClusterInfo(GetClusterInfoRequest) returns (GetClusterInfoResponse) {} // Get all region IDs in the store rpc GetAllRegionsInStore(GetAllRegionsInStoreRequest) returns (GetAllRegionsInStoreResponse) {} // Make this TiKV node return to the status on this node to certain ts. rpc ResetToVersion(ResetToVersionRequest) returns (ResetToVersionResponse) {} } enum DB { INVALID = 0; KV = 1; RAFT = 2; } enum MODULE { UNUSED = 0; KVDB = 1; RAFTDB = 2; READPOOL = 3; SERVER = 4; STORAGE = 5; PD = 6; METRIC = 7; COPROCESSOR = 8; SECURITY = 9; IMPORT = 10; } message GetRequest { DB db = 1; string cf = 2; bytes key = 3; } message GetResponse { bytes value = 1; } message RaftLogRequest { uint64 region_id = 1; uint64 log_index = 2; } message RaftLogResponse { eraftpb.Entry entry = 1; } message RegionInfoRequest { uint64 region_id = 1; } message RegionInfoResponse { raft_serverpb.RaftLocalState raft_local_state = 1; raft_serverpb.RaftApplyState raft_apply_state = 2; raft_serverpb.RegionLocalState region_local_state = 3; } message RegionSizeRequest { uint64 region_id = 1; repeated string cfs = 2; } message RegionSizeResponse { message Entry { string cf = 1; uint64 size = 2; } repeated Entry entries = 1; } message ScanMvccRequest { bytes from_key = 1; bytes to_key = 2; uint64 limit = 3; } message ScanMvccResponse { bytes key = 1; kvrpcpb.MvccInfo info = 2; } enum BottommostLevelCompaction { // Skip bottommost level compaction Skip = 0; // Force bottommost level compaction Force = 1; // Compact bottommost level if there is a compaction filter. IfHaveCompactionFilter = 2; } message CompactRequest { DB db = 1; string cf = 2; bytes from_key = 3; bytes to_key = 4; uint32 threads = 5; BottommostLevelCompaction bottommost_level_compaction = 6; } message CompactResponse { } message InjectFailPointRequest { string name = 1; string actions = 2; } message InjectFailPointResponse { } message RecoverFailPointRequest { string name = 1; } message RecoverFailPointResponse { } message ListFailPointsRequest { } message ListFailPointsResponse { message Entry { string name = 1; string actions = 2; } repeated Entry entries = 1; } message GetMetricsRequest { bool all = 1; } message GetMetricsResponse { string prometheus = 1; string rocksdb_kv = 2; string rocksdb_raft = 3; string jemalloc = 4; uint64 store_id = 5; } message RegionConsistencyCheckRequest { uint64 region_id = 1; } message RegionConsistencyCheckResponse { } message ModifyTikvConfigRequest { MODULE module = 1; string config_name = 2; string config_value = 3; } message ModifyTikvConfigResponse { } message Property { string name = 1; string value = 2; } message GetRegionPropertiesRequest { uint64 region_id = 1; } message GetRegionPropertiesResponse { repeated Property props = 1; } message GetStoreInfoRequest { } message GetStoreInfoResponse { uint64 store_id = 1; kvrpcpb.APIVersion api_version = 2; } message GetClusterInfoRequest { } message GetClusterInfoResponse { uint64 cluster_id = 1; } message GetAllRegionsInStoreRequest { } message GetAllRegionsInStoreResponse { repeated uint64 regions = 1; } message ResetToVersionRequest { uint64 ts = 1; } message ResetToVersionResponse { } kvproto-6.1.0-alpha/proto/diagnosticspb.proto000066400000000000000000000037311421456440000213720ustar00rootroot00000000000000syntax = "proto3"; package diagnosticspb; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // Diagnostics service for TiDB cluster components. service Diagnostics { // Searchs log in the target node rpc search_log(SearchLogRequest) returns (stream SearchLogResponse) {}; // Retrieves server info in the target node rpc server_info(ServerInfoRequest) returns (ServerInfoResponse) {}; } enum LogLevel { UNKNOWN = 0; Debug = 1; Info = 2; Warn = 3; Trace = 4; Critical = 5; Error = 6; } message SearchLogRequest { enum Target { Normal = 0; Slow = 1; } int64 start_time = 1; int64 end_time = 2; repeated LogLevel levels = 3; // We use a string array to represent multiple CNF pattern sceniaor like: // SELECT * FROM t WHERE c LIKE '%s%' and c REGEXP '.*a.*' because // Golang and Rust don't support perl-like (?=re1)(?=re2) repeated string patterns = 4; Target target = 5; } message SearchLogResponse { repeated LogMessage messages = 1; } message LogMessage { int64 time = 1; LogLevel level = 2; string message = 3; } enum ServerInfoType { All = 0; HardwareInfo = 1; SystemInfo = 2; LoadInfo = 3; } message ServerInfoRequest { ServerInfoType tp = 1; } message ServerInfoPair { string key = 1; string value = 2; } message ServerInfoItem { // cpu, memory, disk, network ... string tp = 1; // eg. network: lo1/eth0, cpu: core1/core2, disk: sda1/sda2 string name = 2; // all key-value pairs for specified item, e.g: // ServerInfoItem { // tp = "network" // name = "eth0" // paris = [ // ServerInfoPair { key = "readbytes", value = "4k"}, // ServerInfoPair { key = "writebytes", value = "1k"}, // ] // } repeated ServerInfoPair pairs = 3; } message ServerInfoResponse { repeated ServerInfoItem items = 1; } kvproto-6.1.0-alpha/proto/disk_usage.proto000066400000000000000000000003471421456440000206570ustar00rootroot00000000000000syntax = "proto3"; package disk_usage; import "rustproto.proto"; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; enum DiskUsage { Normal = 0; AlmostFull = 1; AlreadyFull = 2; } kvproto-6.1.0-alpha/proto/encryptionpb.proto000066400000000000000000000062451421456440000212600ustar00rootroot00000000000000// These encryption protobufs are not sent over the network. // Protobufs are used to define a stable backwards compatible persistent storage format. // These definitions are used by both PD and TiKV to keep their implementations similar. syntax = "proto3"; package encryptionpb; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // General encryption metadata for any data type. message EncryptionMeta { // ID of the key used to encrypt the data. uint64 key_id = 1; // Initialization vector (IV) of the data. bytes iv = 2; } // Information about an encrypted file. message FileInfo { // ID of the key used to encrypt the file. uint64 key_id = 1; // Initialization vector (IV) of the file. bytes iv = 2; // Method of encryption algorithm used to encrypted the file. EncryptionMethod method = 3; } message FileDictionary { // A map of file name to file info. map files = 1; } enum EncryptionMethod { UNKNOWN = 0; PLAINTEXT = 1; AES128_CTR = 2; AES192_CTR = 3; AES256_CTR = 4; } // The key used to encrypt the user data. message DataKey { // A sequence of secret bytes used to encrypt data. bytes key = 1; // Method of encryption algorithm used to encrypted data. EncryptionMethod method = 2; // Creation time of the key. uint64 creation_time = 3; // A flag for the key have ever been exposed. bool was_exposed = 4; } message KeyDictionary { // A map of key ID to dat key. map keys = 1; // ID of a key currently in use. uint64 current_key_id = 2; } // Master key config. message MasterKey { oneof backend { MasterKeyPlaintext plaintext = 1; MasterKeyFile file = 2; MasterKeyKms kms = 3; } } // MasterKeyPlaintext indicates content is stored as plaintext. message MasterKeyPlaintext {} // MasterKeyFile is a master key backed by a file containing encryption key in human-readable // hex format. message MasterKeyFile { // Local file path. string path = 1; } // MasterKeyKms is a master key backed by KMS service that manages the encryption key, // and provide API to encrypt and decrypt a data key, which is used to encrypt the content. message MasterKeyKms { // KMS vendor. string vendor = 1; // KMS key id. string key_id = 2; // KMS region. string region = 3; // KMS endpoint. Normally not needed. string endpoint = 4; } message EncryptedContent { // Metadata of the encrypted content. // Eg. IV, method and KMS key ID // It is preferred to define new fields for extra metadata than using this metadata map. map metadata = 1; // Encrypted content. bytes content = 2; // Master key used to encrypt the content. MasterKey master_key = 3; // Initilization vector (IV) used. bytes iv = 4; // Encrypted data key generated by KMS and used to actually encrypt data. // Valid only when KMS is used. bytes ciphertext_key = 5; } kvproto-6.1.0-alpha/proto/enginepb.proto000066400000000000000000000036631421456440000203340ustar00rootroot00000000000000syntax = "proto3"; package enginepb; import "metapb.proto"; import "raft_cmdpb.proto"; import "raft_serverpb.proto"; message CommandRequestHeader { uint64 region_id = 1; uint64 index = 2; uint64 term = 3; // Flush in-memory data to disk. bool sync_log = 4; // Destroy the region. bool destroy = 5; // Additional information for the request. bytes context = 6; } message CommandRequest { CommandRequestHeader header = 1; // We don't enclose normal requests and administrator request // at same time. // kv put / delete repeated raft_cmdpb.Request requests = 2; // region metadata manipulation command. raft_cmdpb.AdminRequest admin_request = 3; // region metadata manipulation result. raft_cmdpb.AdminResponse admin_response = 4; } message CommandRequestBatch { repeated CommandRequest requests = 1; } message CommandResponseHeader { uint64 region_id = 1; // Region is destroyed. bool destroyed = 2; } message CommandResponse { CommandResponseHeader header = 1; raft_serverpb.RaftApplyState apply_state = 2; uint64 applied_term = 3; } message CommandResponseBatch { repeated CommandResponse responses = 1; } message SnapshotState { metapb.Region region = 1; metapb.Peer peer = 2; raft_serverpb.RaftApplyState apply_state = 3; } message SnapshotData { string cf = 1; uint32 checksum = 2; repeated raft_serverpb.KeyValue data = 3; } message SnapshotRequest { oneof chunk { // The first message for snapshots. // It contains the latest region information after applied snapshot. SnapshotState state = 1; // Following messages are always data. SnapshotData data = 2; } } message SnapshotDone {} service Engine { rpc ApplyCommandBatch(stream CommandRequestBatch) returns (stream CommandResponseBatch) {} rpc ApplySnapshot(stream SnapshotRequest) returns (SnapshotDone) {} } kvproto-6.1.0-alpha/proto/errorpb.proto000066400000000000000000000120711421456440000202110ustar00rootroot00000000000000syntax = "proto3"; package errorpb; import "metapb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // NotLeader is the error variant that tells a request be handle by raft leader // is sent to raft follower or learner. message NotLeader { // The requested region ID uint64 region_id = 1; // Region leader of the requested region metapb.Peer leader = 2; } message DiskFull { // The requested store ID repeated uint64 store_id = 1; // The detailed info string reason = 2; } // StoreNotMatch is the error variant that tells the request is sent to wrong store. // (i.e. inconsistency of the store ID that request shows and the real store ID of this server.) message StoreNotMatch { // Store id in request uint64 request_store_id = 1; // Actual store id uint64 actual_store_id = 2; } // RegionNotFound is the error variant that tells there isn't any region in this TiKV // matches the requested region ID. message RegionNotFound { // The requested region ID uint64 region_id = 1; } // RegionNotInitialized is the error variant that tells there isn't any initialized peer // matchesthe request region ID. message RegionNotInitialized { // The request region ID uint64 region_id = 1; } // KeyNotInRegion is the error variant that tells the key the request requires isn't present in // this region. message KeyNotInRegion { // The requested key bytes key = 1; // The requested region ID uint64 region_id = 2; // Start key of the requested region bytes start_key = 3; // Snd key of the requested region bytes end_key = 4; } // EpochNotMatch is the error variant that tells a region has been updated. // (e.g. by splitting / merging, or raft Confchange.) // Hence, a command is based on a stale version of a region. message EpochNotMatch { // Available regions that may be siblings of the requested one. repeated metapb.Region current_regions = 1; } // ServerIsBusy is the error variant that tells the server is too busy to response. message ServerIsBusy { string reason = 1; // The suggested backoff time uint64 backoff_ms = 2; } // StaleCommand is the error variant that tells the command is stale, that is, // the current request term is lower than current raft term. // This can be retried at most time. message StaleCommand { } // RaftEntryTooLarge is the error variant that tells the request is too large to be serialized to a // reasonable small raft entry. // (i.e. greater than the configured value `raft_entry_max_size` in `raftstore`) message RaftEntryTooLarge { // The requested region ID uint64 region_id = 1; // Size of the raft entry uint64 entry_size = 2; } // MaxTimestampNotSynced is the error variant that tells the peer has just become a leader and // updating the max timestamp in the concurrency manager from PD TSO is ongoing. In this case, // the prewrite of an async commit transaction cannot succeed. The client can backoff and // resend the request. message MaxTimestampNotSynced { } // ReadIndexNotReady is the error variant that tells the read index request is not ready, that is, // the current region is in a status that not ready to serve the read index request. For example, // region is in splitting or merging status. // This can be retried at most time. message ReadIndexNotReady { // The reason why the region is not ready to serve read index request string reason = 1; // The requested region ID uint64 region_id = 2; } // ProposalInMergingMode is the error variant that tells the proposal is rejected because raft is // in the merging mode. This may happen when BR/Lightning try to ingest SST. // This can be retried at most time. message ProposalInMergingMode { // The requested region ID uint64 region_id = 1; } message DataIsNotReady { // The requested region ID uint64 region_id = 1; uint64 peer_id = 2; uint64 safe_ts = 3; } message RecoveryInProgress { // The requested region ID uint64 region_id = 1; } // Error wraps all region errors, indicates an error encountered by a request. message Error { reserved "stale_epoch"; // The error message string message = 1; NotLeader not_leader = 2; RegionNotFound region_not_found = 3; KeyNotInRegion key_not_in_region = 4; EpochNotMatch epoch_not_match = 5; ServerIsBusy server_is_busy = 6; StaleCommand stale_command = 7; StoreNotMatch store_not_match = 8; RaftEntryTooLarge raft_entry_too_large = 9; MaxTimestampNotSynced max_timestamp_not_synced = 10; ReadIndexNotReady read_index_not_ready = 11; ProposalInMergingMode proposal_in_merging_mode = 12; DataIsNotReady data_is_not_ready = 13; RegionNotInitialized region_not_initialized = 14; DiskFull disk_full = 15; // Online recovery is still in performing, reject writes to avoid potential issues RecoveryInProgress RecoveryInProgress = 16; } kvproto-6.1.0-alpha/proto/import_kvpb.proto000066400000000000000000000104631421456440000210750ustar00rootroot00000000000000syntax = "proto3"; package import_kvpb; import "import_sstpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // ImportKV provides a service to import key-value pairs to TiKV. // // In order to import key-value pairs to TiKV, the user should: // 1. Open an engine identified by an UUID. // 2. Open write streams to write key-value batches to the opened engine. // Different streams/clients can write to the same engine concurrently. // 3. Close the engine after all write batches have been finished. An // engine can only be closed when all write streams are closed. An // engine can only be closed once, and it can not be opened again // once it is closed. // 4. Import the data in the engine to the target cluster. Note that // the import process is not atomic, it requires the data to be // idempotent on retry. An engine can only be imported after it is // closed. An engine can be imported multiple times, but can not be // imported concurrently. // 5. Clean up the engine after it has been imported. Delete all data // in the engine. An engine can not be cleaned up when it is // writing or importing. service ImportKV { // Switch the target cluster to normal/import mode. rpc SwitchMode(SwitchModeRequest) returns (SwitchModeResponse) {} // Open an engine. rpc OpenEngine(OpenEngineRequest) returns (OpenEngineResponse) {} // Open a write stream to the engine. rpc WriteEngine(stream WriteEngineRequest) returns (WriteEngineResponse) {} // Write to engine, single message version rpc WriteEngineV3(WriteEngineV3Request) returns (WriteEngineResponse) {} // Close the engine. rpc CloseEngine(CloseEngineRequest) returns (CloseEngineResponse) {} // Import the engine to the target cluster. rpc ImportEngine(ImportEngineRequest) returns (ImportEngineResponse) {} // Clean up the engine. rpc CleanupEngine(CleanupEngineRequest) returns (CleanupEngineResponse) {} // Compact the target cluster for better performance. rpc CompactCluster(CompactClusterRequest) returns (CompactClusterResponse) {} // Get current version and commit hash rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {} // Get importer metrics rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse) {} } message SwitchModeRequest { string pd_addr = 1; import_sstpb.SwitchModeRequest request = 2; } message SwitchModeResponse { } message OpenEngineRequest { bytes uuid = 1; bytes key_prefix = 2; } message OpenEngineResponse { } message WriteHead { bytes uuid = 1; } message Mutation { enum OP { Put = 0; } OP op = 1; bytes key = 2; bytes value = 3; } message WriteBatch { uint64 commit_ts = 1; repeated Mutation mutations = 2; } message WriteEngineRequest { oneof chunk { WriteHead head = 1; WriteBatch batch = 2; } } message KVPair { bytes key = 1; bytes value = 2; } message WriteEngineV3Request { bytes uuid = 1; uint64 commit_ts = 2; repeated KVPair pairs = 3; } message WriteEngineResponse { Error error = 1; } message CloseEngineRequest { bytes uuid = 1; } message CloseEngineResponse { Error error = 1; } message ImportEngineRequest { bytes uuid = 1; string pd_addr = 2; } message ImportEngineResponse { } message CleanupEngineRequest { bytes uuid = 1; } message CleanupEngineResponse { } message CompactClusterRequest { string pd_addr = 1; import_sstpb.CompactRequest request = 2; } message CompactClusterResponse { } message GetVersionRequest { } message GetVersionResponse { string version = 1; string commit = 2; } message GetMetricsRequest { } message GetMetricsResponse { string prometheus = 1; } message Error { message EngineNotFound { bytes uuid = 1; } // This can happen if the client hasn't opened the engine, or the server // restarts while the client is writing or closing. An unclosed engine will // be removed on server restart, so the client should not continue but // restart the previous job in that case. EngineNotFound engine_not_found = 1; } kvproto-6.1.0-alpha/proto/import_sstpb.proto000066400000000000000000000202741421456440000212670ustar00rootroot00000000000000syntax = "proto3"; package import_sstpb; import "metapb.proto"; import "errorpb.proto"; import "kvrpcpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; import "brpb.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // ImportSST provides a service to import a generated SST file to a region in TiKV. // // In order to import an SST file to a region, the user should: // 1. Retrieve the meta of the region according to the SST file's range. // 2. Upload the SST file to the servers where the region's peers locate in. // 3. Issue an ingest request to the region's leader with the SST file's metadata. // // It's the user's responsibility to make sure that the SST file is uploaded to // the servers where the region's peers locate in, before issue the ingest // request to the region's leader. However, the region can be scheduled (so the // location of the region's peers will be changed) or split/merged (so the range // of the region will be changed), after the SST file is uploaded, but before // the SST file is ingested. So, the region's epoch is provided in the SST // file's metadata, to guarantee that the region's epoch must be the same // between the SST file is uploaded and ingested later. service ImportSST { // Switch to normal/import mode. rpc SwitchMode(SwitchModeRequest) returns (SwitchModeResponse) {} // Upload an SST file to a server. rpc Upload(stream UploadRequest) returns (UploadResponse) {} // Ingest an uploaded SST file to a region. rpc Ingest(IngestRequest) returns (IngestResponse) {} // Compact the specific range for better performance. rpc Compact(CompactRequest) returns (CompactResponse) {} rpc SetDownloadSpeedLimit(SetDownloadSpeedLimitRequest) returns (SetDownloadSpeedLimitResponse) {} // Download an SST file from an external storage, and performs key-rewrite // after downloading. rpc Download(DownloadRequest) returns (DownloadResponse) {} // Open a write stream to generate sst files rpc Write(stream WriteRequest) returns (WriteResponse) {} rpc RawWrite(stream RawWriteRequest) returns (RawWriteResponse) {} // Ingest Multiple files in one request rpc MultiIngest(MultiIngestRequest) returns (IngestResponse) {} // Collect duplicate data from TiKV. rpc DuplicateDetect(DuplicateDetectRequest) returns (stream DuplicateDetectResponse) {} } enum SwitchMode { Normal = 0; Import = 1; } message SwitchModeRequest { SwitchMode mode = 1; } message SwitchModeResponse { } message Range { bytes start = 1; bytes end = 2; } message SSTMeta { bytes uuid = 1; Range range = 2; uint32 crc32 = 3; uint64 length = 4; string cf_name = 5; uint64 region_id = 6; metapb.RegionEpoch region_epoch = 7; bool end_key_exclusive = 8; // total_kvs and total_bytes is equivalent to PD's approximate_keys and approximate_size // set these values can save time from tikv upload keys and size to PD through Heartbeat. uint64 total_kvs = 9; uint64 total_bytes = 10; // API version implies the encode of the key and value. kvrpcpb.APIVersion api_version = 11; // cipher_iv is used to encrypt/decrypt sst bytes cipher_iv = 12; } // A rewrite rule is applied on the *encoded* keys (the internal storage // representation). message RewriteRule { bytes old_key_prefix = 1; bytes new_key_prefix = 2; uint64 new_timestamp = 3; } message UploadRequest { oneof chunk { SSTMeta meta = 1; bytes data = 2; } } message UploadResponse { } message IngestRequest { kvrpcpb.Context context = 1; SSTMeta sst = 2; } message MultiIngestRequest { kvrpcpb.Context context = 1; repeated SSTMeta ssts = 2; } message IngestResponse { errorpb.Error error = 1; } message CompactRequest { // Compact files in the range and above the output level. // Compact all files if the range is not specified. // Compact all files to the bottommost level if the output level is -1. Range range = 1; int32 output_level = 2; } message CompactResponse { } message DownloadRequest { // The SST meta used to identify the downloaded file. // Must be the same among all nodes in the same Raft group. // Note: the "crc32" and "cf_name" fields are ignored in this request, // and the "range" field represents the closed key range after rewrite // (as origin keys in encoded representation). SSTMeta sst = 2 [(gogoproto.nullable) = false]; // The url field is deprecated, use storage_backend instead reserved 8; reserved "url"; // The file name of the SST file. string name = 9; // Performs a key prefix rewrite after downloading the SST file. // All keys in the SST will be rewritten as: // // new_key = new_key_prefix + old_key[len(old_key_prefix)..] // // When used for TiDB, rewriting the prefix changes the table ID. Please // note that key-rewrite is applied on the origin keys in encoded // representation (the SST itself should still use data keys in encoded // representation). // // You need to ensure that the keys before and after rewriting are in the // same order, otherwise the RPC request will fail. RewriteRule rewrite_rule = 13 [(gogoproto.nullable) = false]; backup.StorageBackend storage_backend = 14; bool is_raw_kv = 15; // cipher_info is used to decrypt sst when download sst backup.CipherInfo cipher_info = 16; } // For now it is just used for distinguishing the error of the request with the error // of gRPC, add more concrete types if it is necessary later. message Error { string message = 1; } message DownloadResponse { // The actual key range (after rewrite) of the downloaded SST. The range is // inclusive in both ends. Range range = 1 [(gogoproto.nullable) = false]; // Whether the SST is empty. An empty SST is prohibited in TiKV, do not // ingest if this field is true. // (Deprecated, should be replaced by checking `length == 0` in the future) bool is_empty = 2; Error error = 3; // The CRC32 checksum of the rewritten SST file (implementation can return // zero, indicating the CRC32 was not calculated). uint32 crc32 = 4; // The actual length of the rewritten SST file. uint64 length = 5; } message SetDownloadSpeedLimitRequest { // The download speed limit (bytes/second). Set to 0 for unlimited speed. uint64 speed_limit = 1; } message SetDownloadSpeedLimitResponse { } message Pair { bytes key = 1; bytes value = 2; enum OP { Put = 0; Delete = 1; } OP op = 3; } message WriteBatch { uint64 commit_ts = 1; repeated Pair pairs = 2; } message WriteRequest { oneof chunk { SSTMeta meta = 1; WriteBatch batch = 2; } } message WriteResponse { Error error = 1; repeated SSTMeta metas = 2; } message RawWriteBatch { uint64 ttl = 1; repeated Pair pairs = 2; } message RawWriteRequest { oneof chunk { SSTMeta meta = 1; RawWriteBatch batch = 2; } } message RawWriteResponse { Error error = 1; repeated SSTMeta metas = 2; } message DuplicateDetectRequest { kvrpcpb.Context context = 1; bytes start_key = 2; bytes end_key = 3; // Return only the keys found by scanning, not their values. bool key_only = 4; // We only check the data whose timestamp is larger than `min_commit_ts`. `min_commit_ts` is exclueded. uint64 min_commit_ts = 5; } message KvPair { bytes key = 1; bytes value = 2; uint64 commit_ts = 3; } message DuplicateDetectResponse { errorpb.Error region_error = 1; Error key_error = 2; // The these keys will be in asc order (but commit time is in desc order), // and the content is just like following: // [ // {key: "key1", value: "value11", commit_ts: 1005}, // {key: "key1", value: "value12", commit_ts: 1004}, // {key: "key1", value: "value13", commit_ts: 1001}, // {key: "key2", value: "value21", commit_ts: 1004}, // {key: "key2", value: "value22", commit_ts: 1002}, // ... // ] repeated KvPair pairs = 3; } kvproto-6.1.0-alpha/proto/kvrpcpb.proto000066400000000000000000001071451421456440000202140ustar00rootroot00000000000000syntax = "proto3"; package kvrpcpb; import "metapb.proto"; import "errorpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; import "deadlock.proto"; import "tracepb.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // This proto file defines requests, responses, and helper messages for KV and raw // APIs of TiKV (see tikvpb.proto). // Transactional commands. // A transactional get command. Lookup a value for `key` in the transaction with // starting timestamp = `version`. message GetRequest { Context context = 1; bytes key = 2; uint64 version = 3; } message GetResponse { // A region error indicates that the request was sent to the wrong TiKV node // (or other, similar errors). errorpb.Error region_error = 1; // A value could not be retrieved due to the state of the database for the requested key. KeyError error = 2; // A successful result. bytes value = 3; // True if the key does not exist in the database. bool not_found = 4; reserved 5; // Time and scan details when processing the request. ExecDetailsV2 exec_details_v2 = 6; } // Scan fetches values for a range of keys; it is part of the transaction with // starting timestamp = `version`. message ScanRequest { Context context = 1; bytes start_key = 2; // The maximum number of results to return. uint32 limit = 3; uint64 version = 4; // Return only the keys found by scanning, not their values. bool key_only = 5; bool reverse = 6; // For compatibility, when scanning forward, the range to scan is [start_key, end_key), where start_key < end_key; // and when scanning backward, it scans [end_key, start_key) in descending order, where end_key < start_key. bytes end_key = 7; // If sample_step > 0, skips 'sample_step - 1' number of keys after each returned key. // locks are not checked. uint32 sample_step = 8; } message ScanResponse { errorpb.Error region_error = 1; // Each KvPair may contain a key error. repeated KvPair pairs = 2; // This KeyError exists when some key is locked but we cannot check locks of all keys. // In this case, `pairs` should be empty and the client should redo scanning all the keys // after resolving the lock. KeyError error = 3; } // A prewrite is the first phase of writing to TiKV. It contains all data to be written in a transaction. // TiKV will write the data in a preliminary state. Data cannot be read until it has been committed. // The client should only commit a transaction once all prewrites succeed. message PrewriteRequest { Context context = 1; // The data to be written to the database. repeated Mutation mutations = 2; // The client picks one key to be primary (unrelated to the primary key concept in SQL). This // key's lock is the source of truth for the state of a transaction. All other locks due to a // transaction will point to the primary lock. bytes primary_lock = 3; // Identifies the transaction being written. uint64 start_version = 4; uint64 lock_ttl = 5; // TiKV can skip some checks, used for speeding up data migration. bool skip_constraint_check = 6; // For pessimistic transaction, some mutations don't need to be locked, for example, non-unique index key. repeated bool is_pessimistic_lock = 7; // How many keys this transaction involves in this region. uint64 txn_size = 8; // For pessimistic transactions only; used to check if a conflict lock is already committed. uint64 for_update_ts = 9; // If min_commit_ts > 0, this is a large transaction request, the final commit_ts // will be inferred from `min_commit_ts`. uint64 min_commit_ts = 10; // When async commit is enabled, `secondaries` should be set as the key list of all secondary // locks if the request prewrites the primary lock. bool use_async_commit = 11; repeated bytes secondaries = 12; // When the transaction involves only one region, it's possible to commit the transaction // directly with 1PC protocol. bool try_one_pc = 13; // The max commit ts is reserved for limiting the commit ts of 1PC or async commit, which can be used to avoid // inconsistency with schema change. uint64 max_commit_ts = 14; // The level of assertion to use on this prewrte request. AssertionLevel assertion_level = 15; } message PrewriteResponse { errorpb.Error region_error = 1; repeated KeyError errors = 2; // 0 if the min_commit_ts is not ready or any other reason that async // commit cannot proceed. The client can then fallback to normal way to // continue committing the transaction if prewrite are all finished. uint64 min_commit_ts = 3; // When the transaction is successfully committed with 1PC protocol, this field will be set to // the commit ts of the transaction. Otherwise, if TiKV failed to commit it with 1PC or the // transaction is not 1PC, the value will be 0. uint64 one_pc_commit_ts = 4; } // Lock a set of keys to prepare to write to them. message PessimisticLockRequest { Context context = 1; // In this case every `Op` of the mutations must be `PessimisticLock`. repeated Mutation mutations = 2; bytes primary_lock = 3; uint64 start_version = 4; uint64 lock_ttl = 5; // Each locking command in a pessimistic transaction has its own timestamp. If locking fails, then // the corresponding SQL statement can be retried with a later timestamp, TiDB does not need to // retry the whole transaction. The name comes from the `SELECT ... FOR UPDATE` SQL statement which // is a locking read. Each `SELECT ... FOR UPDATE` in a transaction will be assigned its own // timestamp. uint64 for_update_ts = 6; // If the request is the first lock request, we don't need to detect deadlock. bool is_first_lock = 7; // Time to wait for lock released in milliseconds when encountering locks. // 0 means using default timeout in TiKV. Negative means no wait. int64 wait_timeout = 8; // If it is true, TiKV will acquire the pessimistic lock regardless of write conflict // and return the latest value. It's only supported for single mutation. bool force = 9 [deprecated = true]; // If it is true, TiKV will return values of the keys if no error, so TiDB can cache the values for // later read in the same transaction. // When 'force' is set to true, this field is ignored. bool return_values = 10; // If min_commit_ts > 0, this is large transaction proto, the final commit_ts // would be infered from min_commit_ts. uint64 min_commit_ts = 11; // If set to true, it means TiKV need to check if the key exists, and return the result in // the `not_founds` feild in the response. This works no matter if `return_values` is set. If // `return_values` is set, it simply makes no difference; otherwise, the `value` field of the // repsonse will be empty while the `not_founds` field still indicates the keys' existence. bool check_existence = 12; } message PessimisticLockResponse { errorpb.Error region_error = 1; repeated KeyError errors = 2; // It carries the latest value and its commit ts if force in PessimisticLockRequest is true. uint64 commit_ts = 3 [deprecated = true]; bytes value = 4 [deprecated = true]; // The values is set if 'return_values' is true in the request and no error. // If 'force' is true, this field is not used. repeated bytes values = 5; // Indicates whether the values at the same index is correspond to an existing key. // In legacy TiKV, this field is not used even 'force' is false. In that case, an empty value indicates // two possible situations: (1) the key does not exist. (2) the key exists but the value is empty. repeated bool not_founds = 6; } // Unlock keys locked using `PessimisticLockRequest`. message PessimisticRollbackRequest { Context context = 1; uint64 start_version = 2; uint64 for_update_ts = 3; repeated bytes keys = 4; } message PessimisticRollbackResponse { errorpb.Error region_error = 1; repeated KeyError errors = 2; } // Used to update the lock_ttl of a psessimistic and/or large transaction to prevent it from been killed. message TxnHeartBeatRequest { Context context = 1; // The key of the lock to update. bytes primary_lock = 2; // Start timestamp of the large transaction. uint64 start_version = 3; // The new TTL the sender would like. uint64 advise_lock_ttl = 4; } message TxnHeartBeatResponse { errorpb.Error region_error = 1; KeyError error = 2; // The TTL actually set on the requested lock. uint64 lock_ttl = 3; } // CheckTxnStatusRequest checks the status of a transaction. // If the transaction is rollbacked/committed, return that result. // If the TTL of the transaction is exhausted, abort that transaction and inform the caller. // Otherwise, returns the TTL information for the transaction. // CheckTxnStatusRequest may also push forward the minCommitTS of a large transaction. message CheckTxnStatusRequest { Context context = 1; // Primary key and lock ts together to locate the primary lock of a transaction. bytes primary_key = 2; // Starting timestamp of the transaction being checked. uint64 lock_ts = 3; // The start timestamp of the transaction which this request is part of. uint64 caller_start_ts = 4; // The client must specify the current time to TiKV using this timestamp. It is used to check TTL // timeouts. It may be inaccurate. uint64 current_ts = 5; // If true, then TiKV will leave a rollback tombstone in the write CF for `primary_key`, even if // that key is not locked. bool rollback_if_not_exist = 6; // This field is set to true only if the transaction is known to fall back from async commit. // Then, CheckTxnStatus treats the transaction as non-async-commit even if the use_async_commit // field in the primary lock is true. bool force_sync_commit = 7; // If the check request is used to resolve or decide the transaction status for a input pessimistic // lock, the transaction status could not be decided if the primary lock is pessimistic too and // it's still uncertain. bool resolving_pessimistic_lock = 8; } message CheckTxnStatusResponse { errorpb.Error region_error = 1; KeyError error = 2; // Three kinds of transaction status: // locked: lock_ttl > 0 // committed: commit_version > 0 // rollbacked: lock_ttl = 0 && commit_version = 0 uint64 lock_ttl = 3; uint64 commit_version = 4; // The action performed by TiKV (and why if the action is to rollback). Action action = 5; LockInfo lock_info = 6; } // Part of the async commit protocol, checks for locks on all supplied keys. If a lock is missing, // does not have a successful status, or belongs to another transaction, TiKV will leave a rollback // tombstone for that key. message CheckSecondaryLocksRequest { Context context = 1; repeated bytes keys = 2; // Identifies the transaction we are investigating. uint64 start_version = 3; } message CheckSecondaryLocksResponse { errorpb.Error region_error = 1; KeyError error = 2; // For each key in `keys` in `CheckSecondaryLocks`, there will be a lock in // this list if there is a lock present and belonging to the correct transaction, // nil otherwise. repeated LockInfo locks = 3; // If any of the locks have been committed, this is the commit ts used. If no // locks have been committed, it will be zero. uint64 commit_ts = 4; } // The second phase of writing to TiKV. If there are no errors or conflicts, then this request // commits a transaction so that its data can be read by other transactions. message CommitRequest { reserved 5; reserved "binlog"; Context context = 1; // Identifies the transaction. uint64 start_version = 2; // All keys in the transaction (to be committed). repeated bytes keys = 3; // Timestamp for the end of the transaction. Must be greater than `start_version`. uint64 commit_version = 4; } message CommitResponse { errorpb.Error region_error = 1; KeyError error = 2; // If the commit ts is derived from min_commit_ts, this field should be set. uint64 commit_version = 3; } // Not yet implemented. message ImportRequest { repeated Mutation mutations = 1; uint64 commit_version = 2; } message ImportResponse { errorpb.Error region_error = 1; string error = 2; } // Cleanup a key by possibly unlocking it. // From 4.0 onwards, this message is no longer used. message CleanupRequest { Context context = 1; bytes key = 2; uint64 start_version = 3; // The current timestamp, used in combination with a lock's TTL to determine // if the lock has expired. If `current_ts == 0`, then the key will be unlocked // irrespective of its TTL. uint64 current_ts = 4; } message CleanupResponse { errorpb.Error region_error = 1; KeyError error = 2; // Set if the key is already committed. uint64 commit_version = 3; } // Similar to a `Get` request. message BatchGetRequest { Context context = 1; repeated bytes keys = 2; uint64 version = 3; } message BatchGetResponse { errorpb.Error region_error = 1; repeated KvPair pairs = 2; reserved 3; // Time and scan details when processing the request. ExecDetailsV2 exec_details_v2 = 4; // This KeyError exists when some key is locked but we cannot check locks of all keys. // In this case, `pairs` should be empty and the client should redo batch get all the keys // after resolving the lock. KeyError error = 5; } // Rollback a prewritten transaction. This will remove the preliminary data from the database, // unlock locks, and leave a rollback tombstone. message BatchRollbackRequest { Context context = 1; // Identify the transaction to be rolled back. uint64 start_version = 2; // The keys to rollback. repeated bytes keys = 3; } message BatchRollbackResponse { errorpb.Error region_error = 1; KeyError error = 2; } // Scan the database for locks. Used at the start of the GC process to find all // old locks. message ScanLockRequest { Context context = 1; // Returns all locks with a start timestamp before `max_version`. uint64 max_version = 2; // Start scanning from this key. bytes start_key = 3; // The maximum number of locks to return. uint32 limit = 4; // The exclusive upperbound for scanning. bytes end_key = 5; } message ScanLockResponse { errorpb.Error region_error = 1; KeyError error = 2; // Info on all locks found by the scan. repeated LockInfo locks = 3; } // For all keys locked by the transaction identified by `start_version`, either // commit or rollback the transaction and unlock the key. message ResolveLockRequest { Context context = 1; uint64 start_version = 2; // `commit_version == 0` means the transaction was rolled back. // `commit_version > 0` means the transaction was committed at the given timestamp. uint64 commit_version = 3; repeated TxnInfo txn_infos = 4; // Only resolve specified keys. repeated bytes keys = 5; } message ResolveLockResponse { errorpb.Error region_error = 1; KeyError error = 2; } // Request TiKV to garbage collect all non-current data older than `safe_point`. message GCRequest { Context context = 1; uint64 safe_point = 2; } message GCResponse { errorpb.Error region_error = 1; KeyError error = 2; } // Delete a range of data from TiKV. // This message should not be used. message DeleteRangeRequest { Context context = 1; bytes start_key = 2; bytes end_key = 3; // If true, the data will not be immediately deleted, but the operation will // still be replicated via Raft. This is used to notify TiKV that the data // will be deleted using `unsafe_destroy_range` soon. bool notify_only = 4; } message DeleteRangeResponse { errorpb.Error region_error = 1; string error = 2; } // Raw commands. message RawGetRequest { Context context = 1; bytes key = 2; string cf = 3; } message RawGetResponse { errorpb.Error region_error = 1; string error = 2; bytes value = 3; bool not_found = 4; } message RawBatchGetRequest { Context context = 1; repeated bytes keys = 2; string cf = 3; } message RawBatchGetResponse { errorpb.Error region_error = 1; repeated KvPair pairs = 2; } message RawPutRequest { Context context = 1; bytes key = 2; bytes value = 3; string cf = 4; uint64 ttl = 5; bool for_cas = 6; } message RawPutResponse { errorpb.Error region_error = 1; string error = 2; } message RawBatchPutRequest { Context context = 1; repeated KvPair pairs = 2; string cf = 3; uint64 ttl = 4 [deprecated=true]; bool for_cas = 5; // The time-to-live for each keys in seconds, and if the length of `ttls` // is exactly one, the ttl will be applied to all keys. Otherwise, the length // mismatch between `ttls` and `pairs` will return an error. repeated uint64 ttls = 6; } message RawBatchPutResponse { errorpb.Error region_error = 1; string error = 2; } message RawDeleteRequest { Context context = 1; bytes key = 2; string cf = 3; bool for_cas = 4; } message RawDeleteResponse { errorpb.Error region_error = 1; string error = 2; } message RawBatchDeleteRequest { Context context = 1; repeated bytes keys = 2; string cf = 3; bool for_cas = 4; } message RawBatchDeleteResponse { errorpb.Error region_error = 1; string error = 2; } message RawScanRequest { Context context = 1; bytes start_key = 2; uint32 limit = 3; bool key_only = 4; string cf = 5; bool reverse = 6; // For compatibility, when scanning forward, the range to scan is [start_key, end_key), where start_key < end_key; // and when scanning backward, it scans [end_key, start_key) in descending order, where end_key < start_key. bytes end_key = 7; } message RawScanResponse { errorpb.Error region_error = 1; repeated KvPair kvs = 2; } message RawDeleteRangeRequest { Context context = 1; bytes start_key = 2; bytes end_key = 3; string cf = 4; } message RawDeleteRangeResponse { errorpb.Error region_error = 1; string error = 2; } message RawBatchScanRequest { Context context = 1; repeated KeyRange ranges = 2; // scanning range uint32 each_limit = 3; // max number of returning kv pairs for each scanning range bool key_only = 4; string cf = 5; bool reverse = 6; } message RawBatchScanResponse { errorpb.Error region_error = 1; repeated KvPair kvs = 2; } // Store commands (sent to a whole TiKV cluster, rather than a certain region). message UnsafeDestroyRangeRequest { Context context = 1; bytes start_key = 2; bytes end_key = 3; } message UnsafeDestroyRangeResponse { errorpb.Error region_error = 1; string error = 2; } message RegisterLockObserverRequest { Context context = 1; uint64 max_ts = 2; } message RegisterLockObserverResponse { string error = 1; } message CheckLockObserverRequest { Context context = 1; uint64 max_ts = 2; } message CheckLockObserverResponse { string error = 1; bool is_clean = 2; repeated LockInfo locks = 3; } message RemoveLockObserverRequest { Context context = 1; uint64 max_ts = 2; } message RemoveLockObserverResponse { string error = 1; } message PhysicalScanLockRequest { Context context = 1; uint64 max_ts = 2; bytes start_key = 3; uint32 limit = 4; } message PhysicalScanLockResponse { string error = 1; repeated LockInfo locks = 2; } // Sent from PD to a TiKV node. message SplitRegionRequest { Context context = 1; bytes split_key = 2 [deprecated=true]; repeated bytes split_keys = 3; // when use it to do batch split, `split_key` should be empty. // Once enabled, the split_key will not be encoded. bool is_raw_kv = 4; } message SplitRegionResponse { errorpb.Error region_error = 1; metapb.Region left = 2 [deprecated=true]; // set when there are only 2 result regions. metapb.Region right = 3 [deprecated=true]; // set when there are only 2 result regions. repeated metapb.Region regions = 4; // include all result regions. } // Sent from TiFlash to a TiKV node. message ReadIndexRequest{ Context context = 1; // TiKV checks the given range if there is any unapplied lock // blocking the read request. uint64 start_ts = 2; repeated KeyRange ranges = 3; } message ReadIndexResponse{ errorpb.Error region_error = 1; uint64 read_index = 2; // If `locked` is set, this read request is blocked by a lock. // The lock should be returned to the client. kvrpcpb.LockInfo locked = 3; } // Commands for debugging transactions. message MvccGetByKeyRequest { Context context = 1; bytes key = 2; } message MvccGetByKeyResponse { errorpb.Error region_error = 1; string error = 2; MvccInfo info = 3; } message MvccGetByStartTsRequest { Context context = 1; uint64 start_ts = 2; } message MvccGetByStartTsResponse { errorpb.Error region_error = 1; string error = 2; bytes key = 3; MvccInfo info = 4; } // Helper messages. // Miscellaneous metadata attached to most requests. message Context { reserved 4; reserved "read_quorum"; uint64 region_id = 1; metapb.RegionEpoch region_epoch = 2; metapb.Peer peer = 3; uint64 term = 5; CommandPri priority = 6; IsolationLevel isolation_level = 7; bool not_fill_cache = 8; bool sync_log = 9; // True means execution time statistics should be recorded and returned. bool record_time_stat = 10; // True means RocksDB scan statistics should be recorded and returned. bool record_scan_stat = 11; bool replica_read = 12; // Read requests can ignore locks belonging to these transactions because either // these transactions are rolled back or theirs commit_ts > read request's start_ts. repeated uint64 resolved_locks = 13; uint64 max_execution_duration_ms = 14; // After a region applies to `applied_index`, we can get a // snapshot for the region even if the peer is a follower. uint64 applied_index = 15; // A hint for TiKV to schedule tasks more fairly. Query with same task ID // may share same priority and resource quota. uint64 task_id = 16; // Not required to read the most up-to-date data, replicas with `safe_ts` >= `start_ts` // can handle read request directly bool stale_read = 17; // Any additional serialized information about the request. bytes resource_group_tag = 18; // Used to tell TiKV whether operations are allowed or not on different disk usages. DiskFullOpt disk_full_opt = 19; // Indicates the request is a retry request and the same request may have been sent before. bool is_retry_request = 20; // API version implies the encode of the key and value. APIVersion api_version = 21; // Read request should read through locks belonging to these transactions because these // transactions are committed and theirs commit_ts <= read request's start_ts. repeated uint64 committed_locks = 22; // The informantion to trace a request sent to TiKV. tracepb.TraceContext trace_context = 23; } // The API version the server and the client is using. // See more details in https://github.com/tikv/rfcs/blob/master/text/0069-api-v2.md. enum APIVersion { // Mainly for TxnKV and not safe to use RawKV along with TxnKV. // // V1 server only accepts V1 requests. Except that the V1 raw requests with TTL // will be rejected. V1 = 0; // Only RawKV is available, and then 8 bytes representing the unix timestamp in // seconds for expiring time will be append to the value of all RawKV kv pairs. // // ------------------------------------------------------------ // | User value | Expire Ts | // ------------------------------------------------------------ // | 0x12 0x34 0x56 | 0x00 0x00 0x00 0x00 0x00 0x00 0xff 0xff | // ------------------------------------------------------------ // // V1TTL server only accepts V1 raw requests. // V1 client should not use `V1TTL` in request. V1 client should always send `V1`. V1TTL = 1; // TxnKV keys start with `x{keyspace id}`, `m`, or `t`. // // RawKV keys must be in `default` CF and all start with `r{keyspace id}` prefix, // where the keyspace id is in varint format (little endian), whose bytes expect // the last one always sets the most significant bit to 1. // // The last byte in the raw value must be a meta flag. For example: // // -------------------------------------- // | User value | Meta flags | // -------------------------------------- // | 0x12 0x34 0x56 | 0x00 (0b00000000) | // -------------------------------------- // // As shown in the example below, the least significant bit of the meta flag // indicates whether the value contains 8 bytes expire ts at the very left to the // meta flags. // // -------------------------------------------------------------------------------- // | User value | Expire Ts | Meta flags | // -------------------------------------------------------------------------------- // | 0x12 0x34 0x56 | 0x00 0x00 0x00 0x00 0x00 0x00 0xff 0xff | 0x01 (0b00000001) | // -------------------------------------------------------------------------------- // // V2 server accpets V2 requests and V1 txn requests that statrts with TiDB key // prefix (`m` and `t`). V2 = 2; } message LockInfo { bytes primary_lock = 1; uint64 lock_version = 2; bytes key = 3; uint64 lock_ttl = 4; // How many keys this transaction involves in this region. uint64 txn_size = 5; Op lock_type = 6; uint64 lock_for_update_ts = 7; // Fields for transactions that are using Async Commit. bool use_async_commit = 8; uint64 min_commit_ts = 9; repeated bytes secondaries = 10; } message KeyError { LockInfo locked = 1; // Client should backoff or cleanup the lock then retry. string retryable = 2; // Client may restart the txn. e.g write conflict. string abort = 3; // Client should abort the txn. WriteConflict conflict = 4; // Write conflict is moved from retryable to here. AlreadyExist already_exist = 5; // Key already exists Deadlock deadlock = 6; // Deadlock is used in pessimistic transaction for single statement rollback. CommitTsExpired commit_ts_expired = 7; // Commit ts is earlier than min commit ts of a transaction. TxnNotFound txn_not_found = 8; // Txn not found when checking txn status. CommitTsTooLarge commit_ts_too_large = 9; // Calculated commit TS exceeds the limit given by the user. AssertionFailed assertion_failed = 10; // Assertion of a `Mutation` is evaluated as a failure. } message WriteConflict { uint64 start_ts = 1; uint64 conflict_ts = 2; bytes key = 3; bytes primary = 4; uint64 conflict_commit_ts = 5; } message AlreadyExist { bytes key = 1; } message Deadlock { uint64 lock_ts = 1; bytes lock_key = 2; uint64 deadlock_key_hash = 3; repeated deadlock.WaitForEntry wait_chain = 4; } message CommitTsExpired { uint64 start_ts = 1; uint64 attempted_commit_ts = 2; bytes key = 3; uint64 min_commit_ts = 4; } message TxnNotFound { uint64 start_ts = 1; bytes primary_key = 2; } message CommitTsTooLarge { uint64 commit_ts = 1; // The calculated commit TS. } message AssertionFailed { uint64 start_ts = 1; bytes key = 2; Assertion assertion = 3; uint64 existing_start_ts = 4; uint64 existing_commit_ts = 5; } enum CommandPri { Normal = 0; // Normal is the default value. Low = 1; High = 2; } enum IsolationLevel { SI = 0; // SI = snapshot isolation RC = 1; // RC = read committed RCCheckTS = 2; // RC read and it's needed to check if there exists more recent versions. } // Operation allowed info during each TiKV storage threshold. enum DiskFullOpt { NotAllowedOnFull = 0; // The default value, means operations are not allowed either under almost full or already full. AllowedOnAlmostFull = 1; // Means operations will be allowed when disk is almost full. AllowedOnAlreadyFull = 2; // Means operations will be allowed when disk is already full. } message TimeDetail { // Off-cpu wall time elapsed in TiKV side. Usually this includes queue waiting time and // other kind of waitings in series. int64 wait_wall_time_ms = 1; // Off-cpu and on-cpu wall time elapsed to actually process the request payload. It does not // include `wait_wall_time`. // This field is very close to the CPU time in most cases. Some wait time spend in RocksDB // cannot be excluded for now, like Mutex wait time, which is included in this field, so that // this field is called wall time instead of CPU time. int64 process_wall_time_ms = 2; // KV read wall Time means the time used in key/value scan and get. int64 kv_read_wall_time_ms = 3; } message ScanInfo { int64 total = 1; int64 processed = 2; int64 read_bytes = 3; } // Only reserved for compatibility. message ScanDetail { ScanInfo write = 1; ScanInfo lock = 2; ScanInfo data = 3; } message ScanDetailV2 { // Number of user keys scanned from the storage. // It does not include deleted version or RocksDB tombstone keys. // For Coprocessor requests, it includes keys that has been filtered out by // Selection. uint64 processed_versions = 1; // Number of bytes of user key-value pairs scanned from the storage, i.e. // total size of data returned from MVCC layer. uint64 processed_versions_size = 8; // Approximate number of MVCC keys meet during scanning. It includes // deleted versions, but does not include RocksDB tombstone keys. // // When this field is notably larger than `processed_versions`, it means // there are a lot of deleted MVCC keys. uint64 total_versions = 2; // Total number of deletes and single deletes skipped over during // iteration, i.e. how many RocksDB tombstones are skipped. uint64 rocksdb_delete_skipped_count = 3; // Total number of internal keys skipped over during iteration. // See https://github.com/facebook/rocksdb/blob/9f1c84ca471d8b1ad7be9f3eebfc2c7e07dfd7a7/include/rocksdb/perf_context.h#L84 for details. uint64 rocksdb_key_skipped_count = 4; // Total number of RocksDB block cache hits. uint64 rocksdb_block_cache_hit_count = 5; // Total number of block reads (with IO). uint64 rocksdb_block_read_count = 6; // Total number of bytes from block reads. uint64 rocksdb_block_read_byte = 7; } message ExecDetails { // Available when ctx.record_time_stat = true or meet slow query. TimeDetail time_detail = 1; // Available when ctx.record_scan_stat = true or meet slow query. ScanDetail scan_detail = 2; // See https://github.com/pingcap/kvproto/pull/689 reserved 3; reserved 4; } message ExecDetailsV2 { // Available when ctx.record_time_stat = true or meet slow query. TimeDetail time_detail = 1; // Available when ctx.record_scan_stat = true or meet slow query. ScanDetailV2 scan_detail_v2 = 2; } message KvPair { KeyError error = 1; bytes key = 2; bytes value = 3; } enum Op { Put = 0; Del = 1; Lock = 2; Rollback = 3; // insert operation has a constraint that key should not exist before. Insert = 4; PessimisticLock = 5; CheckNotExists = 6; } enum Assertion { None = 0; Exist = 1; NotExist = 2; } enum AssertionLevel { // No assertion. Off = 0; // Assertion is enabled, but not enforced when it might affect performance. Fast = 1; // Assertion is enabled and enforced. Strict = 2; } message Mutation { Op op = 1; bytes key = 2; bytes value = 3; Assertion assertion = 4; } message MvccWrite { Op type = 1; uint64 start_ts = 2; uint64 commit_ts = 3; bytes short_value = 4; bool has_overlapped_rollback = 5; bool has_gc_fence = 6; uint64 gc_fence = 7; } message MvccValue { uint64 start_ts = 1; bytes value = 2; } message MvccLock { Op type = 1; uint64 start_ts = 2; bytes primary = 3; bytes short_value = 4; uint64 ttl = 5; uint64 for_update_ts = 6; uint64 txn_size = 7; bool use_async_commit = 8; repeated bytes secondaries = 9; repeated uint64 rollback_ts = 10; } message MvccInfo { MvccLock lock = 1; repeated MvccWrite writes = 2; repeated MvccValue values = 3; } message TxnInfo { uint64 txn = 1; uint64 status = 2; } enum Action { NoAction = 0; TTLExpireRollback = 1; LockNotExistRollback = 2; MinCommitTSPushed = 3; TTLExpirePessimisticRollback = 4; LockNotExistDoNothing = 5; } message KeyRange { bytes start_key = 1; bytes end_key = 2; } enum ExtraOp { Noop = 0; // ReadOldValue represents to output the previous value for delete/update operations. ReadOldValue = 1; } message LeaderInfo { uint64 region_id = 1; uint64 peer_id = 2; uint64 term = 3; metapb.RegionEpoch region_epoch = 4; ReadState read_state = 5; } message ReadState { uint64 applied_index = 1; uint64 safe_ts = 2; } message CheckLeaderRequest { repeated LeaderInfo regions = 1; uint64 ts = 2; } message CheckLeaderResponse { repeated uint64 regions = 1; uint64 ts = 2; } message StoreSafeTSRequest { // Get the minimal `safe_ts` from regions that overlap with the key range [`start_key`, `end_key`) // An empty key range means all regions in the store KeyRange key_range = 1; } message StoreSafeTSResponse { uint64 safe_ts = 1; } message RawGetKeyTTLRequest { Context context = 1; bytes key = 2; string cf = 3; } message RawGetKeyTTLResponse { errorpb.Error region_error = 1; string error = 2; uint64 ttl = 3; bool not_found = 4; } message RawCASRequest { Context context = 1; bytes key = 2; bytes value = 3; bool previous_not_exist = 4; bytes previous_value = 5; string cf = 6; uint64 ttl = 7; } message RawCASResponse { errorpb.Error region_error = 1; string error = 2; bool succeed = 3; // The previous value regardless of whether the comparison is succeed. bool previous_not_exist = 4; bytes previous_value = 5; } message GetLockWaitInfoRequest { Context context = 1; // TODO: There may need some filter options to be used on conditional querying, e.g., finding // the lock waiting status for some specified transaction. } message GetLockWaitInfoResponse { errorpb.Error region_error = 1; string error = 2; repeated deadlock.WaitForEntry entries = 3; } message RawCoprocessorRequest { kvrpcpb.Context context = 1; string copr_name = 2; // Coprorcessor version constraint following SEMVER definition. string copr_version_req = 3; repeated KeyRange ranges = 4; bytes data = 5; } message RawCoprocessorResponse { errorpb.Error region_error = 1; // Error message for cases like if no coprocessor with a matching name is found // or on a version mismatch between plugin_api and the coprocessor. string error = 2; bytes data = 3; } enum ChecksumAlgorithm { Crc64_Xor = 0; } message RawChecksumRequest { Context context = 1; ChecksumAlgorithm algorithm = 2; repeated KeyRange ranges = 3; } message RawChecksumResponse { errorpb.Error region_error = 1; string error = 2; uint64 checksum = 3; uint64 total_kvs = 4; uint64 total_bytes = 5; } kvproto-6.1.0-alpha/proto/metapb.proto000066400000000000000000000100341421456440000200030ustar00rootroot00000000000000syntax = "proto3"; package metapb; import "encryptionpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; message Cluster { uint64 id = 1; // max peer count for a region. // pd will do the auto-balance if region peer count mismatches. uint32 max_peer_count = 2; // more attributes...... } enum StoreState { Up = 0; Offline = 1; Tombstone = 2; } // NodeState is going to replace StoreState to make the state concept more clear. // "Up" is devided into "Preparing" and "Serving" stages so that we can better describe the online process. // "Removing" is just like previous `Offline` which is more accurate. // "Removed" has the same meaning with `Tombstone`. enum NodeState { Preparing = 0; Serving = 1; Removing = 2; Removed = 3; } // Case insensitive key/value for replica constraints. message StoreLabel { string key = 1; string value = 2; } message Store { uint64 id = 1; // Address to handle client requests (kv, cop, etc.) string address = 2; StoreState state = 3; repeated StoreLabel labels = 4; string version = 5; // Address to handle peer requests (raft messages from other store). // Empty means same as address. string peer_address = 6; // Status address provides the HTTP service for external components string status_address = 7; string git_hash = 8; // The start timestamp of the current store int64 start_timestamp = 9; string deploy_path = 10; // The last heartbeat timestamp of the store. int64 last_heartbeat = 11; // If the store is physically destroyed, which means it can never up again. bool physically_destroyed = 12; // NodeState is used to replace StoreState which will be deprecated in the future. NodeState node_state = 13; } message RegionEpoch { // Conf change version, auto increment when add or remove peer uint64 conf_ver = 1; // Region version, auto increment when split or merge uint64 version = 2; } message BucketStats { // total read in bytes of each bucket repeated uint64 read_bytes = 1; // total write in bytes of each bucket repeated uint64 write_bytes = 2; // total read qps of each bucket repeated uint64 read_qps = 3; // total write qps of each bucket repeated uint64 write_qps = 4; // total read keys of each bucket repeated uint64 read_keys = 5; // total write keys of each bucket repeated uint64 write_keys = 6; } message Buckets { uint64 region_id = 1; // A hint indicate if keys have changed. uint64 version = 2; // keys of buckets, include start/end key of region repeated bytes keys = 3; // bucket stats BucketStats stats = 4; // The period in milliseconds that stats are collected with in uint64 period_in_ms = 5; } message Region { uint64 id = 1; // Region key range [start_key, end_key). bytes start_key = 2; bytes end_key = 3; RegionEpoch region_epoch = 4; repeated Peer peers = 5; // Encryption metadata for start_key and end_key. encryption_meta.iv is IV for start_key. // IV for end_key is calculated from (encryption_meta.iv + len(start_key)). // The field is only used by PD and should be ignored otherwise. // If encryption_meta is empty (i.e. nil), it means start_key and end_key are unencrypted. encryptionpb.EncryptionMeta encryption_meta = 6; } enum PeerRole { // Voter -> Voter Voter = 0; // Learner/None -> Learner Learner = 1; // Learner/None -> Voter IncomingVoter = 2; // Voter -> Learner DemotingVoter = 3; // We forbid Voter -> None, it can introduce unavailability as discussed in // etcd-io/etcd#7625 // Learner -> None can be apply directly, doesn't need to be stored as // joint state. } message Peer { uint64 id = 1; uint64 store_id = 2; PeerRole role = 3; } kvproto-6.1.0-alpha/proto/mpp.proto000066400000000000000000000041151421456440000173320ustar00rootroot00000000000000syntax = "proto3"; package mpp; import "gogoproto/gogo.proto"; import "coprocessor.proto"; import "metapb.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option java_package = "org.tikv.kvproto"; // TaskMeta contains meta of a mpp plan, including query's ts and task address. message TaskMeta { uint64 start_ts = 1; // start ts of a query int64 task_id = 2; // if task id is -1 , it indicates a tidb task. int64 partition_id = 3; // Only used for hash partition string address = 4; // target address of this task. } message IsAliveRequest { } message IsAliveResponse { bool available = 1; } // Dipsatch the task request to different tiflash servers. message DispatchTaskRequest { TaskMeta meta = 1; bytes encoded_plan = 2; int64 timeout = 3; repeated coprocessor.RegionInfo regions = 4; // If this task contains table scan, we still need their region info. int64 schema_ver = 5; // Used for partition table scan repeated coprocessor.TableRegions table_regions = 6; } // Get response of DispatchTaskRequest. message DispatchTaskResponse { Error error = 1; repeated metapb.Region retry_regions = 2; } // CancelTaskRequest closes the execution of a task. message CancelTaskRequest { TaskMeta meta = 1; Error error = 2; } message CancelTaskResponse { Error error = 1; } // build connection between different tasks. Data is sent by the tasks that are closer to the data sources. message EstablishMPPConnectionRequest { TaskMeta sender_meta = 1; // node closer to the source TaskMeta receiver_meta = 2; // node closer to the tidb mpp gather. } // when TiFlash sends data to TiDB, Data packets wrap tipb.SelectResponse, i.e., serialize tipb.SelectResponse into data; // when TiFlash sends data to TiFlash, data blocks are serialized into chunks, and the execution_summaries in tipb.SelectResponse are serialized into data only for the last packet. message MPPDataPacket { bytes data = 1; Error error = 2; repeated bytes chunks = 3; } message Error { int32 code = 1; string msg = 2; } kvproto-6.1.0-alpha/proto/pdpb.proto000066400000000000000000000525001421456440000174640ustar00rootroot00000000000000syntax = "proto3"; package pdpb; import "metapb.proto"; import "eraftpb.proto"; import "raft_serverpb.proto"; import "replication_modepb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; service PD { // GetMembers get the member list of this cluster. It does not require // the cluster_id in request matchs the id of this cluster. rpc GetMembers(GetMembersRequest) returns (GetMembersResponse) {} rpc Tso(stream TsoRequest) returns (stream TsoResponse) {} rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse) {} rpc IsBootstrapped(IsBootstrappedRequest) returns (IsBootstrappedResponse) {} rpc AllocID(AllocIDRequest) returns (AllocIDResponse) {} rpc GetStore(GetStoreRequest) returns (GetStoreResponse) {} rpc PutStore(PutStoreRequest) returns (PutStoreResponse) {} rpc GetAllStores(GetAllStoresRequest) returns (GetAllStoresResponse) {} rpc StoreHeartbeat(StoreHeartbeatRequest) returns (StoreHeartbeatResponse) {} rpc RegionHeartbeat(stream RegionHeartbeatRequest) returns (stream RegionHeartbeatResponse) {} rpc GetRegion(GetRegionRequest) returns (GetRegionResponse) {} rpc GetPrevRegion(GetRegionRequest) returns (GetRegionResponse) {} rpc GetRegionByID(GetRegionByIDRequest) returns (GetRegionResponse) {} rpc ScanRegions(ScanRegionsRequest) returns (ScanRegionsResponse) {} rpc AskSplit(AskSplitRequest) returns (AskSplitResponse) { // Use AskBatchSplit instead. option deprecated = true; } rpc ReportSplit(ReportSplitRequest) returns (ReportSplitResponse) { // Use ResportBatchSplit instead. option deprecated = true; } rpc AskBatchSplit(AskBatchSplitRequest) returns (AskBatchSplitResponse) {} rpc ReportBatchSplit(ReportBatchSplitRequest) returns (ReportBatchSplitResponse) {} rpc GetClusterConfig(GetClusterConfigRequest) returns (GetClusterConfigResponse) {} rpc PutClusterConfig(PutClusterConfigRequest) returns (PutClusterConfigResponse) {} rpc ScatterRegion(ScatterRegionRequest) returns (ScatterRegionResponse) {} rpc GetGCSafePoint(GetGCSafePointRequest) returns (GetGCSafePointResponse) {} rpc UpdateGCSafePoint(UpdateGCSafePointRequest) returns (UpdateGCSafePointResponse) {} rpc UpdateServiceGCSafePoint(UpdateServiceGCSafePointRequest) returns (UpdateServiceGCSafePointResponse) {} rpc SyncRegions(stream SyncRegionRequest) returns (stream SyncRegionResponse) {} rpc GetOperator(GetOperatorRequest) returns (GetOperatorResponse) {} rpc SyncMaxTS(SyncMaxTSRequest) returns (SyncMaxTSResponse) {} rpc SplitRegions(SplitRegionsRequest) returns (SplitRegionsResponse) {} rpc SplitAndScatterRegions(SplitAndScatterRegionsRequest) returns (SplitAndScatterRegionsResponse) {} rpc GetDCLocationInfo(GetDCLocationInfoRequest) returns (GetDCLocationInfoResponse) {} rpc StoreGlobalConfig(StoreGlobalConfigRequest) returns (StoreGlobalConfigResponse) {} rpc LoadGlobalConfig(LoadGlobalConfigRequest) returns (LoadGlobalConfigResponse) {} rpc WatchGlobalConfig(WatchGlobalConfigRequest) returns (stream WatchGlobalConfigResponse) {} rpc ReportBuckets(stream ReportBucketsRequest) returns (ReportBucketsResponse) {} rpc ReportMinResolvedTS(ReportMinResolvedTsRequest) returns (ReportMinResolvedTsResponse) {} } message WatchGlobalConfigRequest { } message WatchGlobalConfigResponse { repeated GlobalConfigItem changes = 1; } message StoreGlobalConfigRequest { repeated GlobalConfigItem changes = 1; } message StoreGlobalConfigResponse { Error error = 1; } message LoadGlobalConfigRequest { repeated string names = 1; } message LoadGlobalConfigResponse { repeated GlobalConfigItem items = 1; } message GlobalConfigItem { string name = 1; string value = 2; Error error = 3; } message RequestHeader { // cluster_id is the ID of the cluster which be sent to. uint64 cluster_id = 1; // sender_id is the ID of the sender server, also member ID or etcd ID. uint64 sender_id = 2; } message ResponseHeader { // cluster_id is the ID of the cluster which sent the response. uint64 cluster_id = 1; Error error = 2; } enum ErrorType { OK = 0; UNKNOWN = 1; NOT_BOOTSTRAPPED = 2; STORE_TOMBSTONE = 3; ALREADY_BOOTSTRAPPED = 4; INCOMPATIBLE_VERSION = 5; REGION_NOT_FOUND = 6; GLOBAL_CONFIG_NOT_FOUND = 7; } message Error { ErrorType type = 1; string message = 2; } message TsoRequest { RequestHeader header = 1; uint32 count = 2; string dc_location = 3; } message Timestamp { int64 physical = 1; int64 logical = 2; // Number of suffix bits used for global distinction, // PD client will use this to compute a TSO's logical part. uint32 suffix_bits = 3;} message TsoResponse { ResponseHeader header = 1; uint32 count = 2; Timestamp timestamp = 3; } message BootstrapRequest { RequestHeader header = 1; metapb.Store store = 2; metapb.Region region = 3; } message BootstrapResponse { ResponseHeader header = 1; replication_modepb.ReplicationStatus replication_status = 2; } message IsBootstrappedRequest { RequestHeader header = 1; } message IsBootstrappedResponse { ResponseHeader header = 1; bool bootstrapped = 2; } message AllocIDRequest { RequestHeader header = 1; } message AllocIDResponse { ResponseHeader header = 1; uint64 id = 2; } message GetStoreRequest { RequestHeader header = 1; uint64 store_id = 2; } message GetStoreResponse { ResponseHeader header = 1; metapb.Store store = 2; StoreStats stats = 3; } message PutStoreRequest { RequestHeader header = 1; metapb.Store store = 2; } message PutStoreResponse { ResponseHeader header = 1; replication_modepb.ReplicationStatus replication_status = 2; } message GetAllStoresRequest { RequestHeader header = 1; // Do NOT return tombstone stores if set to true. bool exclude_tombstone_stores = 2; } message GetAllStoresResponse { ResponseHeader header = 1; repeated metapb.Store stores = 2; } message GetRegionRequest { RequestHeader header = 1; bytes region_key = 2; bool need_buckets = 3; } message GetRegionResponse { reserved 4; ResponseHeader header = 1; metapb.Region region = 2; metapb.Peer leader = 3; // Leader considers that these peers are down. repeated PeerStats down_peers = 5; // Pending peers are the peers that the leader can't consider as // working followers. repeated metapb.Peer pending_peers = 6; // buckets isn't nil if GetRegion.* requests set need_buckets. metapb.Buckets buckets = 7; } message GetRegionByIDRequest { RequestHeader header = 1; uint64 region_id = 2; bool need_buckets = 3; } // Use GetRegionResponse as the response of GetRegionByIDRequest. message ScanRegionsRequest { RequestHeader header = 1; bytes start_key = 2; int32 limit = 3; // no limit when limit <= 0. bytes end_key = 4; // end_key is +inf when it is empty. } message Region { metapb.Region region = 1; metapb.Peer leader = 2; // Leader considers that these peers are down. repeated PeerStats down_peers = 3; // Pending peers are the peers that the leader can't consider as // working followers. repeated metapb.Peer pending_peers = 4; } message ScanRegionsResponse { ResponseHeader header = 1; // Keep for backword compatibability. repeated metapb.Region region_metas = 2; repeated metapb.Peer leaders = 3; // Extended region info with down/pending peers. repeated Region regions = 4; } message GetClusterConfigRequest { RequestHeader header = 1; } message GetClusterConfigResponse { ResponseHeader header = 1; metapb.Cluster cluster = 2; } message PutClusterConfigRequest { RequestHeader header = 1; metapb.Cluster cluster = 2; } message PutClusterConfigResponse { ResponseHeader header = 1; } message Member { // name is the name of the PD member. string name = 1; // member_id is the unique id of the PD member. uint64 member_id = 2; repeated string peer_urls = 3; repeated string client_urls = 4; int32 leader_priority = 5; string deploy_path = 6; string binary_version = 7; string git_hash = 8; string dc_location = 9; } message GetMembersRequest { RequestHeader header = 1; } message GetMembersResponse { ResponseHeader header = 1; repeated Member members = 2; Member leader = 3; Member etcd_leader = 4; map tso_allocator_leaders = 5; } message PeerStats { metapb.Peer peer = 1; uint64 down_seconds = 2; } message RegionHeartbeatRequest { RequestHeader header = 1; metapb.Region region = 2; // Leader Peer sending the heartbeat. metapb.Peer leader = 3; // Leader considers that these peers are down. repeated PeerStats down_peers = 4; // Pending peers are the peers that the leader can't consider as // working followers. repeated metapb.Peer pending_peers = 5; // Bytes read/written during this period. uint64 bytes_written = 6; uint64 bytes_read = 7; // Keys read/written during this period. uint64 keys_written = 8; uint64 keys_read = 9; // Approximate region size. uint64 approximate_size = 10; reserved 11; // Actually reported time interval TimeInterval interval = 12; // Approximate number of keys. uint64 approximate_keys = 13; // Term is the term of raft group. uint64 term = 14; replication_modepb.RegionReplicationStatus replication_status = 15; // QueryStats reported write query stats, and there are read query stats in store heartbeat QueryStats query_stats = 16; // cpu_usage is the CPU time usage of the leader region since the last heartbeat, // which is calculated by cpu_time_delta/heartbeat_reported_interval. uint64 cpu_usage = 17; } message ChangePeer { metapb.Peer peer = 1; eraftpb.ConfChangeType change_type = 2; } message ChangePeerV2 { // If changes is empty, it means that to exit joint state. repeated ChangePeer changes = 1; } message TransferLeader { metapb.Peer peer = 1; repeated metapb.Peer peers = 2; } message Merge { metapb.Region target = 1; } message SplitRegion { CheckPolicy policy = 1; repeated bytes keys = 2; } enum CheckPolicy { SCAN = 0; APPROXIMATE = 1; USEKEY = 2; } message RegionHeartbeatResponse { ResponseHeader header = 1; // Notice, Pd only allows handling reported epoch >= current pd's. // Leader peer reports region status with RegionHeartbeatRequest // to pd regularly, pd will determine whether this region // should do ChangePeer or not. // E,g, max peer number is 3, region A, first only peer 1 in A. // 1. Pd region state -> Peers (1), ConfVer (1). // 2. Leader peer 1 reports region state to pd, pd finds the // peer number is < 3, so first changes its current region // state -> Peers (1, 2), ConfVer (1), and returns ChangePeer Adding 2. // 3. Leader does ChangePeer, then reports Peers (1, 2), ConfVer (2), // pd updates its state -> Peers (1, 2), ConfVer (2). // 4. Leader may report old Peers (1), ConfVer (1) to pd before ConfChange // finished, pd stills responses ChangePeer Adding 2, of course, we must // guarantee the second ChangePeer can't be applied in TiKV. ChangePeer change_peer = 2; // Pd can return transfer_leader to let TiKV does leader transfer itself. TransferLeader transfer_leader = 3; // ID of the region uint64 region_id = 4; metapb.RegionEpoch region_epoch = 5; // Leader of the region at the moment of the corresponding request was made. metapb.Peer target_peer = 6; Merge merge = 7; // PD sends split_region to let TiKV split a region into two regions. SplitRegion split_region = 8; // Multiple change peer operations atomically. // Note: PD can use both ChangePeer and ChangePeerV2 at the same time // (not in the same RegionHeartbeatResponse). // Now, PD use ChangePeerV2 in following scenarios: // 1. replacing peers // 2. demoting voter directly ChangePeerV2 change_peer_v2 = 9; } message AskSplitRequest { RequestHeader header = 1; metapb.Region region = 2; } message AskSplitResponse { ResponseHeader header = 1; // We split the region into two, first uses the origin // parent region id, and the second uses the new_region_id. // We must guarantee that the new_region_id is global unique. uint64 new_region_id = 2; // The peer ids for the new split region. repeated uint64 new_peer_ids = 3; } message ReportSplitRequest { RequestHeader header = 1; metapb.Region left = 2; metapb.Region right = 3; } message ReportSplitResponse { ResponseHeader header = 1; } message AskBatchSplitRequest { RequestHeader header = 1; metapb.Region region = 2; uint32 split_count = 3; } message SplitID { uint64 new_region_id = 1; repeated uint64 new_peer_ids = 2; } message AskBatchSplitResponse { ResponseHeader header = 1; repeated SplitID ids = 2; } message ReportBatchSplitRequest { RequestHeader header = 1; repeated metapb.Region regions = 2; } message ReportBatchSplitResponse { ResponseHeader header = 1; } message TimeInterval { // The unix timestamp in seconds of the start of this period. uint64 start_timestamp = 1; // The unix timestamp in seconds of the end of this period. uint64 end_timestamp = 2; } message RecordPair { string key = 1; uint64 value = 2; } message PeerStat { uint64 region_id = 1; uint64 read_keys = 2; uint64 read_bytes = 3; QueryStats query_stats = 4; uint64 written_keys = 5; uint64 written_bytes = 6; } message StoreStats { uint64 store_id = 1; // Capacity for the store. uint64 capacity = 2; // Available size for the store. uint64 available = 3; // Total region count in this store. uint32 region_count = 4; // Current sending snapshot count. uint32 sending_snap_count = 5; // Current receiving snapshot count. uint32 receiving_snap_count = 6; // When the store is started (unix timestamp in seconds). uint32 start_time = 7; // How many region is applying snapshot. uint32 applying_snap_count = 8; // If the store is busy bool is_busy = 9; // Actually used space by db uint64 used_size = 10; // Bytes written for the store during this period. uint64 bytes_written = 11; // Keys written for the store during this period. uint64 keys_written = 12; // Bytes read for the store during this period. uint64 bytes_read = 13; // Keys read for the store during this period. uint64 keys_read = 14; // Actually reported time interval TimeInterval interval = 15; // Threads' CPU usages in the store repeated RecordPair cpu_usages = 16; // Threads' read disk I/O rates in the store repeated RecordPair read_io_rates = 17; // Threads' write disk I/O rates in the store repeated RecordPair write_io_rates = 18; // Operations' latencies in the store repeated RecordPair op_latencies = 19; // Hot peer stat in the store repeated PeerStat peer_stats = 20; // Store query stats QueryStats query_stats = 21; // Score that represents the speed of the store, ranges in [1, 100], lower is better. uint64 slow_score = 22; // Damaged regions on the store that need to be removed by PD. repeated uint64 damaged_regions_id = 23; // If the apply worker is busy, namely high apply wait duration bool is_apply_busy = 24; } message PeerReport { raft_serverpb.RaftLocalState raft_state = 1; raft_serverpb.RegionLocalState region_state = 2; } message StoreReport { repeated PeerReport peer_reports = 1; } message StoreHeartbeatRequest { RequestHeader header = 1; StoreStats stats = 2; // Detailed store report that is only filled up on PD's demand for online unsafe recover. StoreReport store_report = 3; replication_modepb.StoreDRAutoSyncStatus dr_autosync_status = 4; } message RecoveryPlan { repeated metapb.Region creates = 1; repeated metapb.Region updates = 2; repeated uint64 deletes = 3; } message StoreHeartbeatResponse { ResponseHeader header = 1; replication_modepb.ReplicationStatus replication_status = 2; string cluster_version = 3; bool require_detailed_report = 4; RecoveryPlan plan = 5; } message ScatterRegionRequest { RequestHeader header = 1; uint64 region_id = 2 [deprecated=true]; // PD will use these region information if it can't find the region. // For example, the region is just split and hasn't report to PD yet. metapb.Region region = 3; metapb.Peer leader = 4; // If group is defined, the regions with the same group would be scattered as a whole group. // If not defined, the regions would be scattered in a cluster level. string group = 5; // If regions_id is defined, the region_id would be ignored. repeated uint64 regions_id = 6; uint64 retry_limit = 7; } message ScatterRegionResponse { ResponseHeader header = 1; uint64 finished_percentage = 2; } message GetGCSafePointRequest { RequestHeader header = 1; } message GetGCSafePointResponse { ResponseHeader header = 1; uint64 safe_point = 2; } message UpdateGCSafePointRequest { RequestHeader header = 1; uint64 safe_point = 2; } message UpdateGCSafePointResponse { ResponseHeader header = 1; uint64 new_safe_point = 2; } message UpdateServiceGCSafePointRequest { RequestHeader header = 1; bytes service_id = 2; int64 TTL = 3; uint64 safe_point = 4; } message UpdateServiceGCSafePointResponse { ResponseHeader header = 1; bytes service_id = 2; int64 TTL = 3; uint64 min_safe_point = 4; } message RegionStat { // Bytes read/written during this period. uint64 bytes_written = 1; uint64 bytes_read = 2; // Keys read/written during this period. uint64 keys_written = 3; uint64 keys_read = 4; } message SyncRegionRequest{ RequestHeader header = 1; Member member = 2; // the follower PD will use the start index to locate historical changes // that require synchronization. uint64 start_index = 3; } message SyncRegionResponse{ ResponseHeader header = 1; // the leader PD will send the repsonds include // changed regions records and the index of the first record. repeated metapb.Region regions = 2; uint64 start_index = 3; repeated RegionStat region_stats = 4; repeated metapb.Peer region_leaders = 5; // the buckets informations without stats. repeated metapb.Buckets buckets =6; } message GetOperatorRequest { RequestHeader header = 1; uint64 region_id = 2; } enum OperatorStatus { SUCCESS = 0; TIMEOUT = 1; CANCEL = 2; REPLACE = 3; RUNNING = 4; } message GetOperatorResponse { ResponseHeader header = 1; uint64 region_id = 2; bytes desc = 3; OperatorStatus status = 4; bytes kind = 5; } message SyncMaxTSRequest { RequestHeader header = 1; Timestamp max_ts = 2; // If skip_check is true, the sync will try to write the max_ts without checking whether it's bigger. bool skip_check = 3; } message SyncMaxTSResponse { ResponseHeader header = 1; Timestamp max_local_ts = 2; repeated string synced_dcs = 3; } message SplitRegionsRequest { RequestHeader header = 1; repeated bytes split_keys = 2; uint64 retry_limit = 3; } message SplitRegionsResponse { ResponseHeader header = 1; uint64 finished_percentage = 2; repeated uint64 regions_id = 3; } message SplitAndScatterRegionsRequest { RequestHeader header = 1; repeated bytes split_keys = 2; string group = 3; uint64 retry_limit = 4; } message SplitAndScatterRegionsResponse { ResponseHeader header = 1; uint64 split_finished_percentage = 2; uint64 scatter_finished_percentage = 3; repeated uint64 regions_id = 4; } message GetDCLocationInfoRequest { RequestHeader header = 1; string dc_location = 2; } message GetDCLocationInfoResponse { ResponseHeader header = 1; // suffix sign int32 suffix = 2; // max_ts will be included into this response if PD leader think the receiver needs, // which it's set when the number of the max suffix bits changes. Timestamp max_ts = 3; } message QueryStats { uint64 GC = 1; uint64 Get = 2; uint64 Scan = 3; uint64 Coprocessor = 4; uint64 Delete = 5; uint64 DeleteRange = 6; uint64 Put = 7; uint64 Prewrite = 8; uint64 AcquirePessimisticLock = 9; uint64 Commit = 10; uint64 Rollback = 11; } enum QueryKind { Others = 0; GC = 1; Get = 2; Scan = 3; Coprocessor = 4; Delete = 5; DeleteRange = 6; Put = 7; Prewrite = 8; AcquirePessimisticLock = 9; Commit = 10; Rollback = 11; } message ReportBucketsRequest { RequestHeader header = 1; metapb.RegionEpoch region_epoch = 2; metapb.Buckets buckets = 3; } message ReportBucketsResponse { ResponseHeader header = 1; } message ReportMinResolvedTsRequest { RequestHeader header = 1; uint64 store_id = 2; uint64 min_resolved_ts = 3; } message ReportMinResolvedTsResponse { ResponseHeader header = 1; } kvproto-6.1.0-alpha/proto/raft_cmdpb.proto000066400000000000000000000175401421456440000206450ustar00rootroot00000000000000syntax = "proto3"; package raft_cmdpb; import "metapb.proto"; import "errorpb.proto"; import "eraftpb.proto"; import "kvrpcpb.proto"; import "import_sstpb.proto"; import "rustproto.proto"; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; message GetRequest { string cf = 1; bytes key = 2; } message GetResponse { bytes value = 1; } message PutRequest { string cf = 1; bytes key = 2; bytes value = 3; } message PutResponse {} message DeleteRequest { string cf = 1; bytes key = 2; } message DeleteResponse {} message DeleteRangeRequest { string cf = 1; bytes start_key = 2; bytes end_key = 3; bool notify_only = 4; } message DeleteRangeResponse {} message SnapRequest {} message SnapResponse { metapb.Region region = 1; } message PrewriteRequest { bytes key = 1; bytes value = 2; bytes lock = 3; } message PrewriteResponse {} message IngestSSTRequest { import_sstpb.SSTMeta sst = 1; } message IngestSSTResponse {} message ReadIndexRequest { // In replica read, leader uses start_ts and key_ranges to check memory locks. uint64 start_ts = 1; repeated kvrpcpb.KeyRange key_ranges = 2; } message ReadIndexResponse{ uint64 read_index = 1; // The memory lock blocking this read at the leader kvrpcpb.LockInfo locked = 2; } enum CmdType { Invalid = 0; Get = 1; Put = 3; Delete = 4; Snap = 5; Prewrite = 6; DeleteRange = 7; IngestSST = 8; ReadIndex = 9; } message Request { CmdType cmd_type = 1; GetRequest get = 2; PutRequest put = 4; DeleteRequest delete = 5; SnapRequest snap = 6; PrewriteRequest prewrite = 7; DeleteRangeRequest delete_range = 8; IngestSSTRequest ingest_sst = 9; ReadIndexRequest read_index = 10; } message Response { CmdType cmd_type = 1; GetResponse get = 2; PutResponse put = 4; DeleteResponse delete = 5; SnapResponse snap = 6; PrewriteResponse prewrite = 7; DeleteRangeResponse delte_range = 8; IngestSSTResponse ingest_sst = 9; ReadIndexResponse read_index = 10; } message ChangePeerRequest { // This can be only called in internal RaftStore now. eraftpb.ConfChangeType change_type = 1; metapb.Peer peer = 2; } message ChangePeerResponse { metapb.Region region = 1; } message ChangePeerV2Request { repeated ChangePeerRequest changes = 1; } message ChangePeerV2Response { metapb.Region region = 1; } message SplitRequest { // This can be only called in internal RaftStore now. // The split_key must be in the been splitting region. bytes split_key = 1; // We split the region into two, first uses the origin // parent region id, and the second uses the new_region_id. // We must guarantee that the new_region_id is global unique. uint64 new_region_id = 2; // The peer ids for the new split region. repeated uint64 new_peer_ids = 3; // If true, right region derive the origin region_id, // left region use new_region_id. // Will be ignored in batch split, use `BatchSplitRequest::right_derive` instead. bool right_derive = 4 [deprecated=true]; } message SplitResponse { metapb.Region left = 1; metapb.Region right = 2; } message BatchSplitRequest { repeated SplitRequest requests = 1; // If true, the last region derive the origin region_id, // other regions use new ids. bool right_derive = 2; } message BatchSplitResponse { repeated metapb.Region regions = 1; } message CompactLogRequest { uint64 compact_index = 1; uint64 compact_term = 2; } message CompactLogResponse {} message TransferLeaderRequest { metapb.Peer peer = 1; repeated metapb.Peer peers = 2; } message TransferLeaderResponse {} message ComputeHashRequest { bytes context = 1; } message VerifyHashRequest { uint64 index = 1; bytes hash = 2; bytes context = 3; } message VerifyHashResponse {} message PrepareMergeRequest { uint64 min_index = 1; metapb.Region target = 2; } message PrepareMergeResponse {} message CommitMergeRequest { metapb.Region source = 1; uint64 commit = 2; repeated eraftpb.Entry entries = 3; } message CommitMergeResponse {} message RollbackMergeRequest { uint64 commit = 1; } message RollbackMergeResponse {} enum AdminCmdType { InvalidAdmin = 0; ChangePeer = 1; // Use `BatchSplit` instead. Split = 2 [deprecated=true]; CompactLog = 3; TransferLeader = 4; ComputeHash = 5; VerifyHash = 6; PrepareMerge = 7; CommitMerge = 8; RollbackMerge = 9; BatchSplit = 10; ChangePeerV2 = 11; } message AdminRequest { AdminCmdType cmd_type = 1; ChangePeerRequest change_peer = 2; SplitRequest split = 3 [deprecated=true]; CompactLogRequest compact_log = 4; TransferLeaderRequest transfer_leader = 5; VerifyHashRequest verify_hash = 6; PrepareMergeRequest prepare_merge = 7; CommitMergeRequest commit_merge = 8; RollbackMergeRequest rollback_merge = 9; BatchSplitRequest splits = 10; ChangePeerV2Request change_peer_v2 = 11; ComputeHashRequest compute_hash = 12; } message AdminResponse { AdminCmdType cmd_type = 1; ChangePeerResponse change_peer = 2; SplitResponse split = 3 [deprecated=true]; CompactLogResponse compact_log = 4; TransferLeaderResponse transfer_leader = 5; VerifyHashResponse verify_hash = 6; PrepareMergeResponse prepare_merge = 7; CommitMergeResponse commit_merge = 8; RollbackMergeResponse rollback_merge = 9; BatchSplitResponse splits = 10; ChangePeerV2Response change_peer_v2 = 11; } // For get the leader of the region. message RegionLeaderRequest {} message RegionLeaderResponse { metapb.Peer leader = 1; } // For getting more information of the region. // We add some admin operations (ChangePeer, Split...) into the pb job list, // then pd server will peek the first one, handle it and then pop it from the job lib. // But sometimes, the pd server may crash before popping. When another pd server // starts and finds the job is running but not finished, it will first check whether // the raft server already has handled this job. // E,g, for ChangePeer, if we add Peer10 into region1 and find region1 has already had // Peer10, we can think this ChangePeer is finished, and can pop this job from job list // directly. message RegionDetailRequest {} message RegionDetailResponse { metapb.Region region = 1; metapb.Peer leader = 2; } enum StatusCmdType { InvalidStatus = 0; RegionLeader = 1; RegionDetail = 2; } message StatusRequest { StatusCmdType cmd_type = 1; RegionLeaderRequest region_leader = 2; RegionDetailRequest region_detail = 3; } message StatusResponse { StatusCmdType cmd_type = 1; RegionLeaderResponse region_leader = 2; RegionDetailResponse region_detail = 3; } message RaftRequestHeader { uint64 region_id = 1; metapb.Peer peer = 2; // true for read linearization bool read_quorum = 3; // 16 bytes, to distinguish request. bytes uuid = 4; metapb.RegionEpoch region_epoch = 5; uint64 term = 6; bool sync_log = 7; bool replica_read = 8; // Read requests can be responsed directly after the Raft applys to `applied_index`. uint64 applied_index = 9; // Custom flags for this raft request. uint64 flags = 10; bytes flag_data = 11; } message RaftResponseHeader { errorpb.Error error = 1; bytes uuid = 2; uint64 current_term = 3; } message RaftCmdRequest { RaftRequestHeader header = 1; // We can't enclose normal requests and administrator request // at same time. repeated Request requests = 2; AdminRequest admin_request = 3; StatusRequest status_request = 4; } message RaftCmdResponse { RaftResponseHeader header = 1; repeated Response responses = 2; AdminResponse admin_response = 3; StatusResponse status_response = 4; } kvproto-6.1.0-alpha/proto/raft_serverpb.proto000066400000000000000000000051771421456440000214130ustar00rootroot00000000000000syntax = "proto3"; package raft_serverpb; import "eraftpb.proto"; import "metapb.proto"; import "kvrpcpb.proto"; import "disk_usage.proto"; import "rustproto.proto"; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; message RaftMessage { uint64 region_id = 1; metapb.Peer from_peer = 2; metapb.Peer to_peer = 3; eraftpb.Message message = 4; metapb.RegionEpoch region_epoch = 5; // true means to_peer is a tombstone peer and it should remove itself. bool is_tombstone = 6; // Region key range [start_key, end_key). bytes start_key = 7; bytes end_key = 8; // If it has value, to_peer should be removed if merge is never going to complete. metapb.Region merge_target = 9; ExtraMessage extra_msg = 10; bytes extra_ctx = 11; disk_usage.DiskUsage disk_usage = 12; } message RaftTruncatedState { uint64 index = 1; uint64 term = 2; } message SnapshotCFFile { string cf = 1; uint64 size = 2; uint32 checksum = 3; } message SnapshotMeta { repeated SnapshotCFFile cf_files = 1; // true means this snapshot is triggered for load balance bool for_balance = 2; } message SnapshotChunk { RaftMessage message = 1; bytes data = 2; } message Done {} message KeyValue { bytes key = 1; bytes value = 2; } message RaftSnapshotData { metapb.Region region = 1; uint64 file_size = 2; repeated KeyValue data = 3; uint64 version = 4; SnapshotMeta meta = 5; } message StoreIdent { uint64 cluster_id = 1; uint64 store_id = 2; kvrpcpb.APIVersion api_version = 3; } message RaftLocalState { eraftpb.HardState hard_state = 1; uint64 last_index = 2; } message RaftApplyState { uint64 applied_index = 1; uint64 last_commit_index = 3; uint64 commit_index = 4; uint64 commit_term = 5; RaftTruncatedState truncated_state = 2; } enum PeerState { Normal = 0; Applying = 1; Tombstone = 2; Merging = 3; } message MergeState { uint64 min_index = 1; metapb.Region target = 2; uint64 commit = 3; } message RegionLocalState { PeerState state = 1; metapb.Region region = 2; MergeState merge_state = 3; } enum ExtraMessageType { MsgRegionWakeUp = 0; MsgWantRollbackMerge = 1; MsgCheckStalePeer = 2; MsgCheckStalePeerResponse = 3; // If leader is going to sleep, it will send requests to all its followers // to make sure they all agree to sleep. MsgHibernateRequest = 4; MsgHibernateResponse = 5; } message ExtraMessage { ExtraMessageType type = 1; uint64 premerge_commit = 2; repeated metapb.Peer check_peers = 3; } kvproto-6.1.0-alpha/proto/replication_modepb.proto000066400000000000000000000032621421456440000223770ustar00rootroot00000000000000syntax = "proto3"; package replication_modepb; enum ReplicationMode { // The standard mode. Replicate logs to majority peer. MAJORITY = 0; // DR mode. Replicate logs among 2 DCs. DR_AUTO_SYNC = 1; } // The replication status sync from PD to TiKV. message ReplicationStatus { ReplicationMode mode = 1; DRAutoSync dr_auto_sync = 2; } enum DRAutoSyncState { // Raft logs need to sync between different DCs SYNC = 0; // Wait for switching to ASYNC. Stop sync raft logs between DCs. ASYNC_WAIT = 1; // Raft logs need to sync to majority peers ASYNC = 2; // Switching from ASYNC to SYNC mode SYNC_RECOVER = 3; } // The status of dr-autosync mode. message DRAutoSync { // The key of the label that used for distinguish different DC. string label_key = 1; DRAutoSyncState state = 2; // Unique ID of the state, it increases after each state transfer. uint64 state_id = 3; // Duration to wait before switching to SYNC by force (in seconds) int32 wait_sync_timeout_hint = 4; // Stores should only sync messages with available stores when state is ASYNC or ASYNC_WAIT. repeated uint64 available_stores = 5; } enum RegionReplicationState { // The region's state is unknown UNKNOWN = 0; // Logs sync to majority peers SIMPLE_MAJORITY = 1; // Logs sync to different DCs INTEGRITY_OVER_LABEL = 2; } // The replication status sync from TiKV to PD. message RegionReplicationStatus { RegionReplicationState state = 1; // Unique ID of the state, it increases after each state transfer. uint64 state_id = 2; } message StoreDRAutoSyncStatus { DRAutoSyncState state = 1; uint64 state_id = 2; } kvproto-6.1.0-alpha/proto/resource_usage_agent.proto000066400000000000000000000027621421456440000227350ustar00rootroot00000000000000syntax = "proto3"; package resource_usage_agent; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // ResourceUsageAgent is the service for storing resource usage records. service ResourceUsageAgent { // Report the resource usage records. By default, the records with the same // resource group tag will be batched by minute. rpc Report(stream ResourceUsageRecord) returns (EmptyResponse) {} } // TiKV implements ResourceMeteringPubSub service for clients to subscribe to resource metering records. service ResourceMeteringPubSub { // Clients subscribe to resource metering records through this RPC, and TiKV periodically (e.g. per minute) // publishes resource metering records to clients via gRPC stream. rpc Subscribe(ResourceMeteringRequest) returns (stream ResourceUsageRecord) {} } message ResourceMeteringRequest {} message EmptyResponse {} message ResourceUsageRecord { oneof record_oneof { GroupTagRecord record = 1; } } // GroupTagRecord is a set of resource usage data grouped by resource_group_tag. message GroupTagRecord { bytes resource_group_tag = 1; repeated GroupTagRecordItem items = 2; } message GroupTagRecordItem { uint64 timestamp_sec = 1; uint32 cpu_time_ms = 2; uint32 read_keys = 3; uint32 write_keys = 4; } kvproto-6.1.0-alpha/proto/tikvpb.proto000066400000000000000000000252171421456440000200430ustar00rootroot00000000000000syntax = "proto3"; package tikvpb; import "coprocessor.proto"; import "kvrpcpb.proto"; import "mpp.proto"; import "raft_serverpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; option (gogoproto.sizer_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.unmarshaler_all) = true; option (rustproto.lite_runtime_all) = true; option java_package = "org.tikv.kvproto"; // Key/value store API for TiKV. service Tikv { // Commands using a transactional interface. rpc KvGet(kvrpcpb.GetRequest) returns (kvrpcpb.GetResponse) {} rpc KvScan(kvrpcpb.ScanRequest) returns (kvrpcpb.ScanResponse) {} rpc KvPrewrite(kvrpcpb.PrewriteRequest) returns (kvrpcpb.PrewriteResponse) {} rpc KvPessimisticLock(kvrpcpb.PessimisticLockRequest) returns (kvrpcpb.PessimisticLockResponse) {} rpc KVPessimisticRollback(kvrpcpb.PessimisticRollbackRequest) returns (kvrpcpb.PessimisticRollbackResponse) {} rpc KvTxnHeartBeat(kvrpcpb.TxnHeartBeatRequest) returns (kvrpcpb.TxnHeartBeatResponse) {} rpc KvCheckTxnStatus(kvrpcpb.CheckTxnStatusRequest) returns (kvrpcpb.CheckTxnStatusResponse) {} rpc KvCheckSecondaryLocks(kvrpcpb.CheckSecondaryLocksRequest) returns (kvrpcpb.CheckSecondaryLocksResponse) {} rpc KvCommit(kvrpcpb.CommitRequest) returns (kvrpcpb.CommitResponse) {} rpc KvImport(kvrpcpb.ImportRequest) returns (kvrpcpb.ImportResponse) {} rpc KvCleanup(kvrpcpb.CleanupRequest) returns (kvrpcpb.CleanupResponse) {} rpc KvBatchGet(kvrpcpb.BatchGetRequest) returns (kvrpcpb.BatchGetResponse) {} rpc KvBatchRollback(kvrpcpb.BatchRollbackRequest) returns (kvrpcpb.BatchRollbackResponse) {} rpc KvScanLock(kvrpcpb.ScanLockRequest) returns (kvrpcpb.ScanLockResponse) {} rpc KvResolveLock(kvrpcpb.ResolveLockRequest) returns (kvrpcpb.ResolveLockResponse) {} rpc KvGC(kvrpcpb.GCRequest) returns (kvrpcpb.GCResponse) {} rpc KvDeleteRange(kvrpcpb.DeleteRangeRequest) returns (kvrpcpb.DeleteRangeResponse) {} // Raw commands; no transaction support. rpc RawGet(kvrpcpb.RawGetRequest) returns (kvrpcpb.RawGetResponse) {} rpc RawBatchGet(kvrpcpb.RawBatchGetRequest) returns (kvrpcpb.RawBatchGetResponse) {} rpc RawPut(kvrpcpb.RawPutRequest) returns (kvrpcpb.RawPutResponse) {} rpc RawBatchPut(kvrpcpb.RawBatchPutRequest) returns (kvrpcpb.RawBatchPutResponse) {} rpc RawDelete(kvrpcpb.RawDeleteRequest) returns (kvrpcpb.RawDeleteResponse) {} rpc RawBatchDelete(kvrpcpb.RawBatchDeleteRequest) returns (kvrpcpb.RawBatchDeleteResponse) {} rpc RawScan(kvrpcpb.RawScanRequest) returns (kvrpcpb.RawScanResponse) {} rpc RawDeleteRange(kvrpcpb.RawDeleteRangeRequest) returns (kvrpcpb.RawDeleteRangeResponse) {} rpc RawBatchScan(kvrpcpb.RawBatchScanRequest) returns (kvrpcpb.RawBatchScanResponse) {} // Get TTL of the key. Returns 0 if TTL is not set for the key. rpc RawGetKeyTTL(kvrpcpb.RawGetKeyTTLRequest) returns (kvrpcpb.RawGetKeyTTLResponse) {} // Compare if the value in database equals to `RawCASRequest.previous_value` before putting the new value. If not, this request will have no effect and the value in the database will be returned. rpc RawCompareAndSwap(kvrpcpb.RawCASRequest) returns (kvrpcpb.RawCASResponse) {} rpc RawChecksum(kvrpcpb.RawChecksumRequest) returns (kvrpcpb.RawChecksumResponse) {} // Store commands (sent to a each TiKV node in a cluster, rather than a certain region). rpc UnsafeDestroyRange(kvrpcpb.UnsafeDestroyRangeRequest) returns (kvrpcpb.UnsafeDestroyRangeResponse) {} rpc RegisterLockObserver(kvrpcpb.RegisterLockObserverRequest) returns (kvrpcpb.RegisterLockObserverResponse) {} rpc CheckLockObserver(kvrpcpb.CheckLockObserverRequest) returns (kvrpcpb.CheckLockObserverResponse) {} rpc RemoveLockObserver(kvrpcpb.RemoveLockObserverRequest) returns (kvrpcpb.RemoveLockObserverResponse) {} rpc PhysicalScanLock(kvrpcpb.PhysicalScanLockRequest) returns (kvrpcpb.PhysicalScanLockResponse) {} // Commands for executing SQL in the TiKV coprocessor (i.e., 'pushed down' to TiKV rather than // executed in TiDB). rpc Coprocessor(coprocessor.Request) returns (coprocessor.Response) {} rpc CoprocessorStream(coprocessor.Request) returns (stream coprocessor.Response) {} rpc BatchCoprocessor(coprocessor.BatchRequest) returns (stream coprocessor.BatchResponse) {} // Command for executing custom user requests in TiKV coprocessor_v2. rpc RawCoprocessor(kvrpcpb.RawCoprocessorRequest) returns (kvrpcpb.RawCoprocessorResponse) {} // Raft commands (sent between TiKV nodes). rpc Raft(stream raft_serverpb.RaftMessage) returns (raft_serverpb.Done) {} rpc BatchRaft(stream BatchRaftMessage) returns (raft_serverpb.Done) {} rpc Snapshot(stream raft_serverpb.SnapshotChunk) returns (raft_serverpb.Done) {} // Sent from PD or TiDB to a TiKV node. rpc SplitRegion (kvrpcpb.SplitRegionRequest) returns (kvrpcpb.SplitRegionResponse) {} // Sent from TiFlash or TiKV to a TiKV node. rpc ReadIndex(kvrpcpb.ReadIndexRequest) returns (kvrpcpb.ReadIndexResponse) {} // Commands for debugging transactions. rpc MvccGetByKey(kvrpcpb.MvccGetByKeyRequest) returns (kvrpcpb.MvccGetByKeyResponse) {} rpc MvccGetByStartTs(kvrpcpb.MvccGetByStartTsRequest) returns (kvrpcpb.MvccGetByStartTsResponse) {} // Batched commands. rpc BatchCommands(stream BatchCommandsRequest) returns (stream BatchCommandsResponse) {} // These are for mpp execution. rpc DispatchMPPTask(mpp.DispatchTaskRequest) returns (mpp.DispatchTaskResponse) {} rpc CancelMPPTask(mpp.CancelTaskRequest) returns (mpp.CancelTaskResponse) {} rpc EstablishMPPConnection(mpp.EstablishMPPConnectionRequest) returns (stream mpp.MPPDataPacket) {} rpc IsAlive(mpp.IsAliveRequest) returns (mpp.IsAliveResponse) {} /// CheckLeader sends all information (includes region term and epoch) to other stores. /// Once a store receives a request, it checks term and epoch for each region, and sends the regions whose /// term and epoch match with local information in the store. /// After the client collected all responses from all stores, it checks if got a quorum of responses from /// other stores for every region, and decides to advance resolved ts from these regions. rpc CheckLeader(kvrpcpb.CheckLeaderRequest) returns (kvrpcpb.CheckLeaderResponse); /// Get the minimal `safe_ts` from regions at the store rpc GetStoreSafeTS(kvrpcpb.StoreSafeTSRequest) returns (kvrpcpb.StoreSafeTSResponse); /// Get the information about lock waiting from TiKV. rpc GetLockWaitInfo(kvrpcpb.GetLockWaitInfoRequest) returns (kvrpcpb.GetLockWaitInfoResponse); } message BatchCommandsRequest { repeated Request requests = 1; repeated uint64 request_ids = 2; message Request { oneof cmd { kvrpcpb.GetRequest Get = 1; kvrpcpb.ScanRequest Scan = 2; kvrpcpb.PrewriteRequest Prewrite = 3; kvrpcpb.CommitRequest Commit = 4; kvrpcpb.ImportRequest Import = 5; kvrpcpb.CleanupRequest Cleanup = 6; kvrpcpb.BatchGetRequest BatchGet = 7; kvrpcpb.BatchRollbackRequest BatchRollback = 8; kvrpcpb.ScanLockRequest ScanLock = 9; kvrpcpb.ResolveLockRequest ResolveLock = 10; kvrpcpb.GCRequest GC = 11; kvrpcpb.DeleteRangeRequest DeleteRange = 12; kvrpcpb.RawGetRequest RawGet = 13; kvrpcpb.RawBatchGetRequest RawBatchGet = 14; kvrpcpb.RawPutRequest RawPut = 15; kvrpcpb.RawBatchPutRequest RawBatchPut = 16; kvrpcpb.RawDeleteRequest RawDelete = 17; kvrpcpb.RawBatchDeleteRequest RawBatchDelete = 18; kvrpcpb.RawScanRequest RawScan = 19; kvrpcpb.RawDeleteRangeRequest RawDeleteRange = 20; kvrpcpb.RawBatchScanRequest RawBatchScan = 21; coprocessor.Request Coprocessor = 22; kvrpcpb.PessimisticLockRequest PessimisticLock = 23; kvrpcpb.PessimisticRollbackRequest PessimisticRollback = 24; kvrpcpb.CheckTxnStatusRequest CheckTxnStatus = 25; kvrpcpb.TxnHeartBeatRequest TxnHeartBeat = 26; kvrpcpb.CheckSecondaryLocksRequest CheckSecondaryLocks = 33; kvrpcpb.RawCoprocessorRequest RawCoprocessor = 34; // For some test cases. BatchCommandsEmptyRequest Empty = 255; } // Reserved for deprecated VerKV reserved 27 to 32; } } message BatchCommandsResponse { repeated Response responses = 1; repeated uint64 request_ids = 2; // 280 means TiKV gRPC cpu usage is 280%. uint64 transport_layer_load = 3; message Response { oneof cmd { kvrpcpb.GetResponse Get = 1; kvrpcpb.ScanResponse Scan = 2; kvrpcpb.PrewriteResponse Prewrite = 3; kvrpcpb.CommitResponse Commit = 4; kvrpcpb.ImportResponse Import = 5; kvrpcpb.CleanupResponse Cleanup = 6; kvrpcpb.BatchGetResponse BatchGet = 7; kvrpcpb.BatchRollbackResponse BatchRollback = 8; kvrpcpb.ScanLockResponse ScanLock = 9; kvrpcpb.ResolveLockResponse ResolveLock = 10; kvrpcpb.GCResponse GC = 11; kvrpcpb.DeleteRangeResponse DeleteRange = 12; kvrpcpb.RawGetResponse RawGet = 13; kvrpcpb.RawBatchGetResponse RawBatchGet = 14; kvrpcpb.RawPutResponse RawPut = 15; kvrpcpb.RawBatchPutResponse RawBatchPut = 16; kvrpcpb.RawDeleteResponse RawDelete = 17; kvrpcpb.RawBatchDeleteResponse RawBatchDelete = 18; kvrpcpb.RawScanResponse RawScan = 19; kvrpcpb.RawDeleteRangeResponse RawDeleteRange = 20; kvrpcpb.RawBatchScanResponse RawBatchScan = 21; coprocessor.Response Coprocessor = 22; kvrpcpb.PessimisticLockResponse PessimisticLock = 23; kvrpcpb.PessimisticRollbackResponse PessimisticRollback = 24; kvrpcpb.CheckTxnStatusResponse CheckTxnStatus = 25; kvrpcpb.TxnHeartBeatResponse TxnHeartBeat = 26; kvrpcpb.CheckSecondaryLocksResponse CheckSecondaryLocks = 33; kvrpcpb.RawCoprocessorResponse RawCoprocessor = 34; // For some test cases. BatchCommandsEmptyResponse Empty = 255; } // Reserved for deprecated VerKV reserved 27 to 32; } } message BatchRaftMessage { repeated raft_serverpb.RaftMessage msgs = 1; } message BatchCommandsEmptyRequest { // ID of the test request. uint64 test_id = 1; // TiKV needs to delay at least such a time to response the client. uint64 delay_time = 2; } message BatchCommandsEmptyResponse { // ID of the test request. uint64 test_id = 1; } kvproto-6.1.0-alpha/proto/tracepb.proto000066400000000000000000000032111421456440000201520ustar00rootroot00000000000000syntax = "proto3"; package tracepb; option java_package = "org.tikv.kvproto"; service TraceRecordPubSub { // Subscribe the Trace records generated on this service. The service will periodically (e.g. per minute) // publishes Trace records to clients via gRPC stream. rpc Subscribe(TraceRecordRequest) returns (stream TraceRecord) {} } message TraceRecordRequest {} message TraceRecord { oneof record_oneof { Report report = 1; NotifyCollect notify_collect = 2; } } message RemoteParentSpan { // A unique id to identify the request. It's usually a UUID. uint64 trace_id = 1; // The span of remote caller that is awaiting the request. uint64 span_id = 2; } // The context of the request to be traced. message TraceContext { repeated RemoteParentSpan remote_parent_spans = 1; // Report the trace records only if the duration of handling the request exceeds the threshold. uint32 duration_threshold_ms = 2; } // Report the spans collected when handling a request on a service. message Report { repeated RemoteParentSpan remote_parent_spans = 1; repeated Span spans = 2; } // Notify the subscriber to persis the spans of the trace. message NotifyCollect { uint64 trace_id = 1; } message Span { // The unique span id within the spans with the same `trace_id`. // The most significant 32 bits should be random number generated by each service instance. uint64 span_id = 1; uint64 parent_id = 2; uint64 begin_unix_ns = 3; uint64 duration_ns = 4; string event = 5; repeated Property properties = 6; } message Property { string key = 1; string value = 2; } kvproto-6.1.0-alpha/scripts/000077500000000000000000000000001421456440000157745ustar00rootroot00000000000000kvproto-6.1.0-alpha/scripts/check.sh000077500000000000000000000007561421456440000174200ustar00rootroot00000000000000#!/usr/bin/env bash check_protoc_version() { version=$(protoc --version) major=$(echo ${version} | sed -n -e 's/.*\([0-9]\{1,\}\)\.[0-9]\{1,\}\.[0-9]\{1,\}.*/\1/p') minor=$(echo ${version} | sed -n -e 's/.*[0-9]\{1,\}\.\([0-9]\{1,\}\)\.[0-9]\{1,\}.*/\1/p') if [ "$major" -eq 3 ] && [ "$minor" -eq 8 ]; then return 0 fi echo "protoc version not match, version 3.8.x is needed, current version: ${version}" return 1 } if ! check_protoc_version; then exit 1 fi kvproto-6.1.0-alpha/scripts/common.sh000066400000000000000000000007311421456440000176210ustar00rootroot00000000000000#!/usr/bin/env bash function push() { pushd $1 >/dev/null 2>&1 } function pop() { popd >/dev/null 2>&1 } function sed_inplace() { # bsd sed does not support --version. if `sed --version > /dev/null 2>&1`; then sed -i "$@" else sed -i '' "$@" fi } function clean_gogo_proto() { local file=$1 sed_inplace '/gogo.proto/d' ${file} sed_inplace '/option\ *(gogoproto/d' ${file} sed_inplace -e 's/\[.*gogoproto.*\]//g' ${file} } export -f clean_gogo_proto kvproto-6.1.0-alpha/scripts/docker-build.sh000077500000000000000000000000711421456440000206750ustar00rootroot00000000000000#!/usr/bin/env bash docker build . -t tikv/kvproto:3.8.0 kvproto-6.1.0-alpha/scripts/docker-run.sh000077500000000000000000000001421421456440000204010ustar00rootroot00000000000000#!/usr/bin/env bash docker run --rm -i -t -v "$(pwd):$(pwd)" -w "$(pwd)" tikv/kvproto:3.8.0 "$@" kvproto-6.1.0-alpha/scripts/generate_cpp.sh000077500000000000000000000014561421456440000207750ustar00rootroot00000000000000#!/usr/bin/env bash set -euo pipefail SCRIPTS_DIR=$(dirname "$0") source $SCRIPTS_DIR/common.sh echo "generate cpp code..." KVPROTO_ROOT="$SCRIPTS_DIR/.." cd $KVPROTO_ROOT GRPC_INCLUDE=.:../include rm -rf proto-cpp && mkdir -p proto-cpp rm -rf cpp/kvproto && mkdir cpp/kvproto cp proto/* proto-cpp/ sed_inplace '/gogo.proto/d' proto-cpp/* sed_inplace '/option\ *(gogoproto/d' proto-cpp/* sed_inplace -e 's/\[.*gogoproto.*\]//g' proto-cpp/* pushd proto-cpp >/dev/null protoc -I${GRPC_INCLUDE} --cpp_out ../cpp/kvproto *.proto protoc -I${GRPC_INCLUDE} --grpc_out ../cpp/kvproto --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` *.proto pop pushd include >/dev/null protoc -I${GRPC_INCLUDE} --cpp_out ../cpp/kvproto *.proto google/api/http.proto google/api/annotations.proto popd >/dev/null rm -rf proto-cpp kvproto-6.1.0-alpha/scripts/generate_go.sh000077500000000000000000000033671421456440000206230ustar00rootroot00000000000000#!/usr/bin/env bash SCRIPTS_DIR=$(dirname "$0") source $SCRIPTS_DIR/common.sh push $SCRIPTS_DIR/.. KVPROTO_ROOT=`pwd` pop PROGRAM=$(basename "$0") GOPATH=$(go env GOPATH) if [ -z $GOPATH ]; then printf "Error: the environment variable GOPATH is not set, please set it before running %s\n" $PROGRAM > /dev/stderr exit 1 fi GO_PREFIX_PATH=github.com/pingcap/kvproto/pkg export PATH=$KVPROTO_ROOT/_tools/bin:$GOPATH/bin:$PATH echo "install tools..." GO111MODULE=off go get github.com/twitchtv/retool GO111MODULE=off retool sync || exit 1 function collect() { file=$(basename $1) base_name=$(basename $file ".proto") mkdir -p ../pkg/$base_name if [ -z $GO_OUT_M ]; then GO_OUT_M="M$file=$GO_PREFIX_PATH/$base_name" else GO_OUT_M="$GO_OUT_M,M$file=$GO_PREFIX_PATH/$base_name" fi } # Although eraftpb.proto is copying from raft-rs, however there is no # official go code ship with the crate, so we need to generate it manually. collect include/eraftpb.proto collect include/rustproto.proto cd proto for file in `ls *.proto` do collect $file done echo "generate go code..." ret=0 function gen() { base_name=$(basename $1 ".proto") protoc -I.:../include --grpc-gateway_out=logtostderr=true:../pkg/$base_name --gofast_out=plugins=grpc,$GO_OUT_M:../pkg/$base_name $1 || ret=$? cd ../pkg/$base_name sed_inplace -E 's/import _ \"gogoproto\"//g' *.pb*.go sed_inplace -E 's/import fmt \"fmt\"//g' *.pb*.go sed_inplace -E 's/import io \"io\"//g' *.pb*.go sed_inplace -E 's/import math \"math\"//g' *.pb*.go sed_inplace -E 's/import _ \".*rustproto\"//' *.pb*.go goimports -w *.pb*.go cd ../../proto } gen ../include/eraftpb.proto for file in `ls *.proto` do gen $file done exit $ret kvproto-6.1.0-alpha/src/000077500000000000000000000000001421456440000150745ustar00rootroot00000000000000kvproto-6.1.0-alpha/src/lib.rs000066400000000000000000000166531421456440000162230ustar00rootroot00000000000000#[allow(dead_code)] #[allow(unknown_lints)] #[allow(clippy::all)] #[allow(renamed_and_removed_lints)] #[allow(bare_trait_objects)] #[allow(deprecated)] mod protos { include!(concat!(env!("OUT_DIR"), "/protos/mod.rs")); use raft_proto::eraftpb; } pub use protos::*; #[cfg(feature = "prost-codec")] pub mod prost_adapt { use crate::backup::{error, ClusterIdError, Error}; use crate::import_kvpb::{write_engine_request, WriteBatch, WriteEngineRequest, WriteHead}; use crate::import_sstpb::{upload_request, SstMeta, UploadRequest}; use crate::{errorpb, kvrpcpb}; impl UploadRequest { pub fn set_data(&mut self, v: Vec) { self.chunk = Some(upload_request::Chunk::Data(v)); } pub fn get_data(&self) -> &[u8] { match &self.chunk { Some(upload_request::Chunk::Data(v)) => v, _ => &[], } } pub fn set_meta(&mut self, v: SstMeta) { self.chunk = Some(upload_request::Chunk::Meta(v)); } pub fn get_meta(&self) -> &SstMeta { match &self.chunk { Some(upload_request::Chunk::Meta(v)) => v, _ => SstMeta::default_ref(), } } pub fn has_meta(&self) -> bool { match self.chunk { Some(upload_request::Chunk::Meta(_)) => true, _ => false, } } } impl WriteEngineRequest { pub fn set_head(&mut self, v: WriteHead) { self.chunk = Some(write_engine_request::Chunk::Head(v)); } pub fn get_head(&self) -> &WriteHead { match &self.chunk { Some(write_engine_request::Chunk::Head(v)) => v, _ => WriteHead::default_ref(), } } pub fn has_head(&self) -> bool { match self.chunk { Some(write_engine_request::Chunk::Head(_)) => true, _ => false, } } pub fn set_batch(&mut self, v: WriteBatch) { self.chunk = Some(write_engine_request::Chunk::Batch(v)); } pub fn get_batch(&self) -> &WriteBatch { match &self.chunk { Some(write_engine_request::Chunk::Batch(v)) => v, _ => WriteBatch::default_ref(), } } pub fn has_batch(&self) -> bool { match self.chunk { Some(write_engine_request::Chunk::Batch(_)) => true, _ => false, } } pub fn take_batch(&mut self) -> WriteBatch { if self.has_batch() { match self.chunk.take() { Some(write_engine_request::Chunk::Batch(v)) => v, _ => unreachable!(), } } else { WriteBatch::default() } } } impl Error { pub fn set_region_error(&mut self, v: errorpb::Error) { self.detail = Some(error::Detail::RegionError(v)); } pub fn set_kv_error(&mut self, v: kvrpcpb::KeyError) { self.detail = Some(error::Detail::KvError(v)); } pub fn set_cluster_id_error(&mut self, v: ClusterIdError) { self.detail = Some(error::Detail::ClusterIdError(v)); } pub fn get_region_error(&self) -> &errorpb::Error { match &self.detail { Some(error::Detail::RegionError(v)) => v, _ => errorpb::Error::default_ref(), } } pub fn get_kv_error(&self) -> &kvrpcpb::KeyError { match &self.detail { Some(error::Detail::KvError(v)) => v, _ => kvrpcpb::KeyError::default_ref(), } } pub fn get_cluster_id_error(&self) -> &ClusterIdError { match &self.detail { Some(error::Detail::ClusterIdError(v)) => v, _ => ClusterIdError::default_ref(), } } pub fn has_region_error(&self) -> bool { match self.detail { Some(error::Detail::RegionError(_)) => true, _ => false, } } pub fn has_kv_error(&self) -> bool { match self.detail { Some(error::Detail::KvError(_)) => true, _ => false, } } pub fn has_cluster_id_error(&self) -> bool { match self.detail { Some(error::Detail::ClusterIdError(_)) => true, _ => false, } } pub fn mut_region_error(&mut self) -> &mut errorpb::Error { if let Some(error::Detail::RegionError(_)) = self.detail { } else { self.detail = Some(error::Detail::RegionError(errorpb::Error::default())); } match self.detail { Some(error::Detail::RegionError(ref mut v)) => v, _ => unreachable!(), } } pub fn mut_kv_error(&mut self) -> &mut kvrpcpb::KeyError { if let Some(error::Detail::KvError(_)) = self.detail { } else { self.detail = Some(error::Detail::KvError(kvrpcpb::KeyError::default())); } match self.detail { Some(error::Detail::KvError(ref mut v)) => v, _ => unreachable!(), } } pub fn mut_cluster_id_error(&mut self) -> &mut ClusterIdError { if let Some(error::Detail::ClusterIdError(_)) = self.detail { } else { self.detail = Some(error::Detail::ClusterIdError(ClusterIdError::default())); } match self.detail { Some(error::Detail::ClusterIdError(ref mut v)) => v, _ => unreachable!(), } } } } pub mod cdc_adapt { #[cfg(not(feature = "prost-codec"))] pub mod pb { impl ::std::fmt::Debug for crate::cdcpb::Event_oneof_event { #[allow(unused_variables)] fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { let mut buf = String::new(); match self { crate::cdcpb::Event_oneof_event::Entries(v) => ::protobuf::PbPrint::fmt(v, "Entries", &mut buf), crate::cdcpb::Event_oneof_event::Admin(v) => ::protobuf::PbPrint::fmt(v, "Admin", &mut buf), crate::cdcpb::Event_oneof_event::Error(v) => ::protobuf::PbPrint::fmt(v, "Error", &mut buf), crate::cdcpb::Event_oneof_event::ResolvedTs(v) => ::protobuf::PbPrint::fmt(v, "ResolvedTs", &mut buf), crate::cdcpb::Event_oneof_event::LongTxn(v) => ::protobuf::PbPrint::fmt(v, "Long", &mut buf), } write!(f, "{}", buf) } } #[allow(dead_code)] fn assert_fmt_debug() { fn require_impl_debug(_: T) {} require_impl_debug(crate::cdcpb::Event_oneof_event::Entries(::std::default::Default::default())); require_impl_debug(crate::cdcpb::ChangeDataEvent::default()); } } #[cfg(feature = "prost-codec")] pub mod prost { #[allow(dead_code)] fn assert_fmt_debug() { fn require_impl_debug(_: T) {} require_impl_debug(crate::cdcpb::event::Event::Entries(::std::default::Default::default())); require_impl_debug(crate::cdcpb::ChangeDataEvent::default()); } } } kvproto-6.1.0-alpha/tools.json000066400000000000000000000007301421456440000163400ustar00rootroot00000000000000{ "Tools": [ { "Repository": "github.com/gogo/protobuf/protoc-gen-gofast", "Commit": "636bf0302bc95575d69441b25a2603156ffdddf1" }, { "Repository": "golang.org/x/tools/cmd/goimports", "Commit": "04b5d21e00f1f47bd824a6ade581e7189bacde87" }, { "Repository": "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway", "Commit": "f7120437bb4f6c71f7f5076ad65a45310de2c009" } ], "RetoolVersion": "1.3.7" }