tikv-python 0.1.0__py3-none-any.whl

tikv/_async/_pd.py

@@ -0,0 +1,167 @@
+"""Client for the Placement Driver (PD), TiKV's cluster metadata service."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import grpc
+from google.protobuf.message import Message
+
+from .._backoff import Backoff, Wait, describe, log
+from .._errors import PDError
+from .._proto import pdpb_pb2 as pdpb
+from .._region import Region, RegionCache, make_region
+from .._rpc import (
+    PD_GET_MEMBERS,
+    PD_GET_PREV_REGION,
+    PD_GET_REGION,
+    PD_GET_STORE,
+    PD_SCAN_REGIONS,
+    Method,
+    Response,
+    is_retryable,
+    strip_scheme,
+)
+from ._compat import Lock, sleep
+from ._transport import Transport
+
+CALLER_ID = "tikv-python"
+
+# PD answers metadata queries quickly; a slower reply means a sick leader,
+# so give up on it early and rediscover instead of burning the whole budget.
+RPC_TIMEOUT = 3.0
+
+
+class PDClient:
+    """Finds the PD leader and asks it where regions and stores are."""
+
+    def __init__(self, endpoints: Iterable[str], transport: Transport, cache: RegionCache) -> None:
+        self._endpoints = list(dict.fromkeys(map(strip_scheme, endpoints)))
+        self._transport = transport
+        self._cache = cache
+        self._lock = Lock()
+        self._leader: str | None = None
+        self.cluster_id = 0
+
+    async def region(self, key: bytes, backoff: Backoff) -> Region:
+        """The region containing *key*."""
+        while True:
+            region = await self._fetch_region(PD_GET_REGION, key, backoff)
+            if region is not None:
+                return region
+            # PD has no region for this key yet, e.g. right after bootstrap.
+            await sleep(backoff.delay(Wait.REGION_MISS, PDError(f"no region found for key {key!r}")))
+
+    async def region_by_end(self, key: bytes, backoff: Backoff) -> Region:
+        """The region in which *key* is a valid exclusive upper bound."""
+        while True:
+            region = await self.region(key, backoff)
+            if region.start != key or not key:
+                return region
+            # *key* opens this region, so the keys below it live in the one
+            # before.  GetPrevRegion returns exactly that (like client-go).
+            previous = await self._fetch_region(PD_GET_PREV_REGION, key, backoff)
+            if previous is not None:
+                return previous
+            # The regions merged in between: start over.
+            await sleep(backoff.delay(Wait.REGION_MISS, PDError(f"no region found before key {key!r}")))
+
+    async def _fetch_region(
+        self, method: Method[pdpb.GetRegionResponse], key: bytes, backoff: Backoff
+    ) -> Region | None:
+        response = await self._call(method, pdpb.GetRegionRequest(region_key=key), backoff)
+        if not response.HasField("region"):
+            return None
+        region = make_region(response.region, response.leader)
+        self._cache.put(region)
+        return region
+
+    async def scan_regions(self, start: bytes, end: bytes, limit: int, backoff: Backoff) -> list[Region]:
+        """Up to *limit* consecutive regions overlapping ``[start, end)``."""
+        request = pdpb.ScanRegionsRequest(start_key=start, end_key=end, limit=limit)
+        response = await self._call(PD_SCAN_REGIONS, request, backoff)
+        if response.regions:
+            regions = [make_region(r.region, r.leader) for r in response.regions]
+        else:  # older PD versions only fill the legacy fields
+            regions = [
+                make_region(m, leader)
+                for m, leader in zip(response.region_metas, response.leaders, strict=False)
+            ]
+        for region in regions:
+            self._cache.put(region)
+        return regions
+
+    async def store_address(self, store_id: int, backoff: Backoff) -> str:
+        """The client-facing address of TiKV store *store_id*."""
+        address = self._cache.store_address(store_id)
+        if address is None:
+            response = await self._call(PD_GET_STORE, pdpb.GetStoreRequest(store_id=store_id), backoff)
+            address = strip_scheme(response.store.address)
+            self._cache.set_store_address(store_id, address)
+        return address
+
+    async def _call(self, method: Method[Response], request: Message, backoff: Backoff) -> Response:
+        """Send *request* to the PD leader, following leader changes."""
+        while True:
+            leader = await self._leader_address(backoff)
+            request.header.cluster_id = self.cluster_id  # type: ignore[attr-defined]
+            request.header.caller_id = CALLER_ID  # type: ignore[attr-defined]
+            timeout = min(RPC_TIMEOUT, backoff.remaining())
+            try:
+                response = await self._transport.call(leader, method, request, timeout)
+            except grpc.RpcError as error:
+                if not is_retryable(error):
+                    raise PDError(f"{method.path} failed: {describe(error)}") from error
+                self._leader = None  # the leader may have moved; rediscover it
+                await sleep(backoff.delay(Wait.PD_RPC, error))
+                continue
+
+            header_error = response.header.error  # type: ignore[attr-defined]
+            if header_error.type == pdpb.OK:
+                return response
+            failure = PDError(
+                f"{method.path} failed: {pdpb.ErrorType.Name(header_error.type)}: {header_error.message}"
+            )
+            if header_error.type != pdpb.REGION_NOT_FOUND:
+                raise failure
+            await sleep(backoff.delay(Wait.REGION_MISS, failure))
+
+    async def _leader_address(self, backoff: Backoff) -> str:
+        leader = self._leader
+        if leader is not None:
+            return leader
+        async with self._lock:
+            while self._leader is None:
+                await self._discover(backoff)
+            return self._leader
+
+    async def _discover(self, backoff: Backoff) -> None:
+        """Ask the known PD members who the leader is."""
+        cause: Exception = PDError("no PD endpoint answered")
+        rejected: list[str] = []
+        for endpoint in list(self._endpoints):
+            timeout = min(RPC_TIMEOUT, backoff.remaining())
+            try:
+                response = await self._transport.call(
+                    endpoint, PD_GET_MEMBERS, pdpb.GetMembersRequest(), timeout
+                )
+            except grpc.RpcError as error:
+                if not is_retryable(error):
+                    rejected.append(f"{endpoint} is not a PD server: {describe(error)}")
+                cause = error
+                continue
+            if not response.leader.client_urls:
+                cause = PDError(f"PD at {endpoint} reports no leader (election in progress?)")
+                continue
+            # Learn about every member so we survive losing the seed endpoints.
+            for member in response.members:
+                for url in member.client_urls:
+                    if strip_scheme(url) not in self._endpoints:
+                        self._endpoints.append(strip_scheme(url))
+            self.cluster_id = response.header.cluster_id
+            self._leader = strip_scheme(response.leader.client_urls[0])
+            log.debug("PD leader is %s (cluster %d)", self._leader, self.cluster_id)
+            return
+        if len(rejected) == len(self._endpoints):  # retrying cannot help
+            raise PDError("; ".join(rejected)) from cause
+        await sleep(backoff.delay(Wait.PD_RPC, cause))

tikv/_async/_transport.py

@@ -0,0 +1,52 @@
+"""A pool of gRPC channels, one per server address."""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+import grpc
+from google.protobuf.message import Message
+
+from .._rpc import CHANNEL_OPTIONS, Method, Response
+from ._compat import Channel, open_channel
+
+
+class Transport:
+    """Sends unary requests to PD and TiKV servers over shared channels."""
+
+    def __init__(self, credentials: grpc.ChannelCredentials | None = None) -> None:
+        self._credentials = credentials
+        self._lock = threading.Lock()  # never held across an await
+        self._channels: dict[str, Channel] = {}
+        self._stubs: dict[tuple[str, str], Any] = {}
+
+    async def call(
+        self, address: str, method: Method[Response], request: Message, timeout: float
+    ) -> Response:
+        stub = self._stubs.get((address, method.path))
+        if stub is None:
+            stub = self._channel(address).unary_unary(
+                method.path,
+                request_serializer=type(request).SerializeToString,
+                response_deserializer=method.response.FromString,
+            )
+            self._stubs[address, method.path] = stub
+        response: Response = await stub(request, timeout=timeout)
+        return response
+
+    def _channel(self, address: str) -> Channel:
+        with self._lock:
+            channel = self._channels.get(address)
+            if channel is None:
+                channel = open_channel(address, self._credentials, CHANNEL_OPTIONS)
+                self._channels[address] = channel
+            return channel
+
+    async def close(self) -> None:
+        with self._lock:
+            channels = list(self._channels.values())
+            self._channels.clear()
+            self._stubs.clear()
+        for channel in channels:
+            await channel.close()

tikv/_backoff.py

@@ -0,0 +1,78 @@
+"""Exponential backoff bounded by a per-operation deadline."""
+
+from __future__ import annotations
+
+import enum
+import logging
+import random
+import time
+
+from ._errors import TimeoutError
+
+log = logging.getLogger("tikv")
+
+
+class Wait(enum.Enum):
+    """Why an operation is backing off; each reason has its own schedule.
+
+    Values are ``(base, cap)`` in seconds, following client-go's defaults.
+    """
+
+    REGION_MISS = (0.002, 0.5)  # stale region cache: refresh and retry soon
+    REGION_SCHEDULING = (0.002, 0.5)  # leader election, merge, split in progress
+    TIKV_RPC = (0.1, 2.0)  # store unreachable
+    PD_RPC = (0.1, 3.0)  # placement driver unreachable or electing a leader
+    SERVER_BUSY = (2.0, 10.0)  # store is overloaded
+
+
+class Backoff:
+    """Tracks retries of one logical operation against its deadline."""
+
+    __slots__ = ("_attempts", "deadline", "timeout")
+
+    def __init__(self, timeout: float, *, deadline: float | None = None) -> None:
+        self.timeout = timeout
+        self.deadline = time.monotonic() + timeout if deadline is None else deadline
+        self._attempts: dict[Wait, int] = {}
+
+    def remaining(self) -> float:
+        """Seconds left before the deadline, never negative."""
+        return max(0.0, self.deadline - time.monotonic())
+
+    def fork(self) -> Backoff:
+        """A backoff for a sub-request: same deadline and retry history.
+
+        The fork escalates independently from here on, so concurrent
+        sub-requests do not inflate each other's delays.
+        """
+        forked = Backoff(self.timeout, deadline=self.deadline)
+        forked._attempts = dict(self._attempts)
+        return forked
+
+    def delay(self, wait: Wait, cause: BaseException, *, hint: float = 0.0) -> float:
+        """Return how long to sleep before the next attempt.
+
+        Raises :class:`~tikv.TimeoutError` from *cause* when sleeping would
+        overrun the deadline, so callers never retry past their budget.
+        """
+        base, cap = wait.value
+        attempt = self._attempts.get(wait, 0)
+        self._attempts[wait] = attempt + 1
+        ceiling = min(cap, base * 2.0**attempt)
+        # "Equal jitter": at least half the ceiling, so retries stay spread out.
+        delay = max(hint, ceiling / 2 + random.uniform(0, ceiling / 2))
+        if delay >= self.remaining():
+            raise TimeoutError(
+                f"operation did not complete within {self.timeout:g}s: {describe(cause)}"
+            ) from cause
+        log.debug("retrying in %.3fs (%s): %s", delay, wait.name.lower(), describe(cause))
+        return delay
+
+
+def describe(error: BaseException) -> str:
+    """A one-line description of *error*, including gRPC status details."""
+    details = getattr(error, "details", None)
+    code = getattr(error, "code", None)
+    if callable(details) and callable(code):
+        return f"gRPC {code().name}: {details()}"
+    return str(error) or type(error).__name__

tikv/_errors.py

@@ -0,0 +1,53 @@
+"""Exceptions raised by the TiKV client.
+
+Every exception derives from :class:`TiKVError`, so ``except tikv.TiKVError``
+catches anything the library raises on purpose.  Transient failures (leader
+changes, region splits, busy servers, unreachable stores) are retried
+internally and only surface as :class:`TimeoutError` once the operation's time
+budget runs out.
+"""
+
+from __future__ import annotations
+
+import builtins
+
+__all__ = [
+    "PDError",
+    "RegionError",
+    "ServerError",
+    "TiKVError",
+    "TimeoutError",
+    "UndeterminedError",
+]
+
+
+class TiKVError(Exception):
+    """Base class for all errors raised by this library."""
+
+
+class TimeoutError(TiKVError, builtins.TimeoutError):
+    """The operation did not complete within the client's ``timeout``.
+
+    The last transient error, if any, is attached as ``__cause__``.
+    """
+
+
+class PDError(TiKVError):
+    """The Placement Driver rejected a request."""
+
+
+class ServerError(TiKVError):
+    """A TiKV server rejected a request, for example because a key is too large."""
+
+
+class RegionError(TiKVError):
+    """A region error that retrying cannot resolve, such as an oversized write."""
+
+
+class UndeterminedError(TiKVError):
+    """A non-idempotent request failed in flight; it may or may not have been applied.
+
+    Raised only by :meth:`RawClient.compare_and_swap`, which is never retried
+    blindly: replaying a swap that already succeeded would report a spurious
+    failure.  Read the key to find out what happened.
+    """

tikv/_keys.py

@@ -0,0 +1,109 @@
+"""Argument validation and key-range arithmetic shared by both clients.
+
+Internally an empty ``end`` key means "+inf", as on the wire.  The public API
+uses ``None`` for that instead, because ``b""`` is itself a valid key.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Iterator, Sequence
+from datetime import timedelta
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def as_bytes(value: object, what: str) -> bytes:
+    if isinstance(value, bytes):
+        return value
+    if isinstance(value, (bytearray, memoryview)):
+        return bytes(value)
+    if isinstance(value, str):
+        raise TypeError(f"{what} must be bytes, not str; encode it first, e.g. {what}.encode()")
+    raise TypeError(f"{what} must be bytes, not {type(value).__name__}")
+
+
+def as_key(key: object) -> bytes:
+    return as_bytes(key, "key")
+
+
+def as_value(value: object) -> bytes:
+    return as_bytes(value, "value")
+
+
+def ttl_seconds(ttl: float | timedelta | None) -> int:
+    """Convert a TTL to whole seconds, rounding up; 0 means "no expiry"."""
+    if ttl is None:
+        return 0
+    if isinstance(ttl, timedelta):
+        seconds = ttl.total_seconds()
+    elif isinstance(ttl, (int, float)) and not isinstance(ttl, bool):
+        seconds = float(ttl)
+    else:
+        raise TypeError(f"ttl must be a number of seconds or a timedelta, not {type(ttl).__name__}")
+    if not seconds > 0 or math.isinf(seconds):
+        raise ValueError(f"ttl must be a positive, finite duration, got {ttl!r}")
+    return math.ceil(seconds)
+
+
+def prefix_end(prefix: bytes) -> bytes:
+    """The smallest key greater than every key starting with *prefix*.
+
+    Returns ``b""`` (+inf) when no such key exists, e.g. for ``b"\\xff\\xff"``.
+    """
+    stripped = prefix.rstrip(b"\xff")
+    if not stripped:
+        return b""
+    return stripped[:-1] + bytes([stripped[-1] + 1])
+
+
+def key_range(start: object | None, end: object | None, prefix: object | None) -> tuple[bytes, bytes] | None:
+    """Resolve public ``start``/``end``/``prefix`` arguments to ``(start, end)``.
+
+    Returns ``None`` when the range is empty.
+    """
+    if prefix is not None:
+        if start is not None or end is not None:
+            raise ValueError("pass either prefix or start/end, not both")
+        lo = as_bytes(prefix, "prefix")
+        return lo, prefix_end(lo)
+    lo = b"" if start is None else as_bytes(start, "start")
+    if end is None:
+        return lo, b""
+    hi = as_bytes(end, "end")
+    return (lo, hi) if lo < hi else None
+
+
+def min_end(a: bytes, b: bytes) -> bytes:
+    """The smaller of two exclusive upper bounds, where ``b""`` is +inf."""
+    if not a:
+        return b
+    if not b:
+        return a
+    return min(a, b)
+
+
+def chunked(
+    items: Sequence[T],
+    *,
+    max_count: int,
+    max_bytes: int = 0,
+    size: Callable[[T], int] | None = None,
+) -> Iterator[list[T]]:
+    """Split *items* into runs of at most *max_count* items.
+
+    With a *size* function, runs also stay within *max_bytes*; a single item
+    larger than that still gets a run of its own.
+    """
+    chunk: list[T] = []
+    total = 0
+    for item in items:
+        item_size = size(item) if size is not None else 0
+        if chunk and (len(chunk) >= max_count or (size is not None and total + item_size > max_bytes)):
+            yield chunk
+            chunk, total = [], 0
+        chunk.append(item)
+        total += item_size
+    if chunk:
+        yield chunk

tikv/_proto/__init__.py

@@ -0,0 +1,2 @@
+# Generated by scripts/generate_protos.py. DO NOT EDIT.
+"""Protobuf messages for the TiKV and PD wire protocols."""

tikv/_proto/errorpb_pb2.py

@@ -0,0 +1,68 @@
+# Generated by scripts/generate_protos.py. DO NOT EDIT.
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: errorpb.proto
+# Protobuf Python Version: 4.25.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from . import metapb_pb2 as metapb__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rerrorpb.proto\x12\x07\x65rrorpb\x1a\x0cmetapb.proto\"<\n\tNotLeader\x12\x11\n\tregion_id\x18\x01 \x01(\x04\x12\x1c\n\x06leader\x18\x02 \x01(\x0b\x32\x0c.metapb.Peer\"\x1e\n\tIsWitness\x12\x11\n\tregion_id\x18\x01 \x01(\x04\",\n\x08\x44iskFull\x12\x10\n\x08store_id\x18\x01 \x03(\x04\x12\x0e\n\x06reason\x18\x02 \x01(\t\"B\n\rStoreNotMatch\x12\x18\n\x10request_store_id\x18\x01 \x01(\x04\x12\x17\n\x0f\x61\x63tual_store_id\x18\x02 \x01(\x04\"#\n\x0eRegionNotFound\x12\x11\n\tregion_id\x18\x01 \x01(\x04\")\n\x14RegionNotInitialized\x12\x11\n\tregion_id\x18\x01 \x01(\x04\"T\n\x0eKeyNotInRegion\x12\x0b\n\x03key\x18\x01 \x01(\x0c\x12\x11\n\tregion_id\x18\x02 \x01(\x04\x12\x11\n\tstart_key\x18\x03 \x01(\x0c\x12\x0f\n\x07\x65nd_key\x18\x04 \x01(\x0c\"8\n\rEpochNotMatch\x12\'\n\x0f\x63urrent_regions\x18\x01 \x03(\x0b\x32\x0e.metapb.Region\"d\n\x0cServerIsBusy\x12\x0e\n\x06reason\x18\x01 \x01(\t\x12\x12\n\nbackoff_ms\x18\x02 \x01(\x04\x12\x19\n\x11\x65stimated_wait_ms\x18\x03 \x01(\r\x12\x15\n\rapplied_index\x18\x04 \x01(\x04\"\x0e\n\x0cStaleCommand\":\n\x11RaftEntryTooLarge\x12\x11\n\tregion_id\x18\x01 \x01(\x04\x12\x12\n\nentry_size\x18\x02 \x01(\x04\"\x17\n\x15MaxTimestampNotSynced\"6\n\x11ReadIndexNotReady\x12\x0e\n\x06reason\x18\x01 \x01(\t\x12\x11\n\tregion_id\x18\x02 \x01(\x04\"*\n\x15ProposalInMergingMode\x12\x11\n\tregion_id\x18\x01 \x01(\x04\"E\n\x0e\x44\x61taIsNotReady\x12\x11\n\tregion_id\x18\x01 \x01(\x04\x12\x0f\n\x07peer_id\x18\x02 \x01(\x04\x12\x0f\n\x07safe_ts\x18\x03 \x01(\x04\"\'\n\x12RecoveryInProgress\x12\x11\n\tregion_id\x18\x01 \x01(\x04\"D\n\x13\x46lashbackInProgress\x12\x11\n\tregion_id\x18\x01 \x01(\x04\x12\x1a\n\x12\x66lashback_start_ts\x18\x02 \x01(\x04\")\n\x14\x46lashbackNotPrepared\x12\x11\n\tregion_id\x18\x01 \x01(\x04\"@\n\x0eMismatchPeerId\x12\x17\n\x0frequest_peer_id\x18\x01 \x01(\x04\x12\x15\n\rstore_peer_id\x18\x02 \x01(\x04\"%\n\x12UndeterminedResult\x12\x0f\n\x07message\x18\x01 \x01(\t\"\xbd\x08\n\x05\x45rror\x12\x0f\n\x07message\x18\x01 \x01(\t\x12&\n\nnot_leader\x18\x02 \x01(\x0b\x32\x12.errorpb.NotLeader\x12\x31\n\x10region_not_found\x18\x03 \x01(\x0b\x32\x17.errorpb.RegionNotFound\x12\x32\n\x11key_not_in_region\x18\x04 \x01(\x0b\x32\x17.errorpb.KeyNotInRegion\x12/\n\x0f\x65poch_not_match\x18\x05 \x01(\x0b\x32\x16.errorpb.EpochNotMatch\x12-\n\x0eserver_is_busy\x18\x06 \x01(\x0b\x32\x15.errorpb.ServerIsBusy\x12,\n\rstale_command\x18\x07 \x01(\x0b\x32\x15.errorpb.StaleCommand\x12/\n\x0fstore_not_match\x18\x08 \x01(\x0b\x32\x16.errorpb.StoreNotMatch\x12\x38\n\x14raft_entry_too_large\x18\t \x01(\x0b\x32\x1a.errorpb.RaftEntryTooLarge\x12@\n\x18max_timestamp_not_synced\x18\n \x01(\x0b\x32\x1e.errorpb.MaxTimestampNotSynced\x12\x38\n\x14read_index_not_ready\x18\x0b \x01(\x0b\x32\x1a.errorpb.ReadIndexNotReady\x12@\n\x18proposal_in_merging_mode\x18\x0c \x01(\x0b\x32\x1e.errorpb.ProposalInMergingMode\x12\x32\n\x11\x64\x61ta_is_not_ready\x18\r \x01(\x0b\x32\x17.errorpb.DataIsNotReady\x12=\n\x16region_not_initialized\x18\x0e \x01(\x0b\x32\x1d.errorpb.RegionNotInitialized\x12$\n\tdisk_full\x18\x0f \x01(\x0b\x32\x11.errorpb.DiskFull\x12\x37\n\x12RecoveryInProgress\x18\x10 \x01(\x0b\x32\x1b.errorpb.RecoveryInProgress\x12\x39\n\x13\x46lashbackInProgress\x18\x11 \x01(\x0b\x32\x1c.errorpb.FlashbackInProgress\x12;\n\x14\x46lashbackNotPrepared\x18\x12 \x01(\x0b\x32\x1d.errorpb.FlashbackNotPrepared\x12&\n\nis_witness\x18\x13 \x01(\x0b\x32\x12.errorpb.IsWitness\x12\x31\n\x10mismatch_peer_id\x18\x14 \x01(\x0b\x32\x17.errorpb.MismatchPeerId\x12\x38\n\x13undetermined_result\x18\x16 \x01(\x0b\x32\x1b.errorpb.UndeterminedResultb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'errorpb_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_NOTLEADER']._serialized_start=40
+  _globals['_NOTLEADER']._serialized_end=100
+  _globals['_ISWITNESS']._serialized_start=102
+  _globals['_ISWITNESS']._serialized_end=132
+  _globals['_DISKFULL']._serialized_start=134
+  _globals['_DISKFULL']._serialized_end=178
+  _globals['_STORENOTMATCH']._serialized_start=180
+  _globals['_STORENOTMATCH']._serialized_end=246
+  _globals['_REGIONNOTFOUND']._serialized_start=248
+  _globals['_REGIONNOTFOUND']._serialized_end=283
+  _globals['_REGIONNOTINITIALIZED']._serialized_start=285
+  _globals['_REGIONNOTINITIALIZED']._serialized_end=326
+  _globals['_KEYNOTINREGION']._serialized_start=328
+  _globals['_KEYNOTINREGION']._serialized_end=412
+  _globals['_EPOCHNOTMATCH']._serialized_start=414
+  _globals['_EPOCHNOTMATCH']._serialized_end=470
+  _globals['_SERVERISBUSY']._serialized_start=472
+  _globals['_SERVERISBUSY']._serialized_end=572
+  _globals['_STALECOMMAND']._serialized_start=574
+  _globals['_STALECOMMAND']._serialized_end=588
+  _globals['_RAFTENTRYTOOLARGE']._serialized_start=590
+  _globals['_RAFTENTRYTOOLARGE']._serialized_end=648
+  _globals['_MAXTIMESTAMPNOTSYNCED']._serialized_start=650
+  _globals['_MAXTIMESTAMPNOTSYNCED']._serialized_end=673
+  _globals['_READINDEXNOTREADY']._serialized_start=675
+  _globals['_READINDEXNOTREADY']._serialized_end=729
+  _globals['_PROPOSALINMERGINGMODE']._serialized_start=731
+  _globals['_PROPOSALINMERGINGMODE']._serialized_end=773
+  _globals['_DATAISNOTREADY']._serialized_start=775
+  _globals['_DATAISNOTREADY']._serialized_end=844
+  _globals['_RECOVERYINPROGRESS']._serialized_start=846
+  _globals['_RECOVERYINPROGRESS']._serialized_end=885
+  _globals['_FLASHBACKINPROGRESS']._serialized_start=887
+  _globals['_FLASHBACKINPROGRESS']._serialized_end=955
+  _globals['_FLASHBACKNOTPREPARED']._serialized_start=957
+  _globals['_FLASHBACKNOTPREPARED']._serialized_end=998
+  _globals['_MISMATCHPEERID']._serialized_start=1000
+  _globals['_MISMATCHPEERID']._serialized_end=1064
+  _globals['_UNDETERMINEDRESULT']._serialized_start=1066
+  _globals['_UNDETERMINEDRESULT']._serialized_end=1103
+  _globals['_ERROR']._serialized_start=1106
+  _globals['_ERROR']._serialized_end=2191
+# @@protoc_insertion_point(module_scope)