diff --git a/test/integration/aeon/conftest.py b/test/integration/aeon/conftest.py new file mode 100644 index 000000000..4666ac35a --- /dev/null +++ b/test/integration/aeon/conftest.py @@ -0,0 +1,88 @@ +import os +from pathlib import Path +from signal import SIGQUIT +from subprocess import PIPE, STDOUT, Popen, run + +import pytest + +from utils import wait_for_lines_in_output + + +@pytest.fixture(scope="session") +def certificates(tmp_path_factory: pytest.TempPathFactory) -> dict[str, Path]: + dir = tmp_path_factory.mktemp("aeon_cert") + cmd = (Path(__file__).parent / "generate-keys.sh", dir) + returncode = run(cmd).returncode + assert returncode == 0, "Some error on generate certificates" + cert = { + "ca": dir / "ca.crt", + "s_private": dir / "server.key", + "s_public": dir / "server.crt", + "c_private": dir / "client.key", + "c_public": dir / "client.crt", + } + for k, v in cert.items(): + assert v.exists(), f"Not found {k} certificate" + return cert + + +@pytest.fixture(scope="session") +def mock_aeon(tmp_path_factory) -> Path: + server_dir = Path(__file__).parent / "server" + exec = tmp_path_factory.mktemp("aeon_mock") / "aeon" + result = run(f"go build -C {server_dir} -o {exec}".split()) + assert result.returncode == 0, "Failed build mock aeon server" + return exec + + +@pytest.fixture(params=[50052, "@aeon_unix_socket", "AEON"]) +def aeon_plain(mock_aeon, tmp_path, request): + cmd = [mock_aeon] + param = request.param + if isinstance(param, int): + cmd.append(f"-port={param}") + elif isinstance(param, str): + if param[0] != "@": + param = tmp_path / param + cmd.append(f"-unix={param}") + + aeon = Popen( + cmd, + env=dict(os.environ, GRPC_GO_LOG_SEVERITY_LEVEL="info"), + stderr=STDOUT, + stdout=PIPE, + text=True, + ) + print(wait_for_lines_in_output(aeon.stdout, ["ListenSocket created"])) + yield param + aeon.send_signal(SIGQUIT) + assert aeon.wait(5) == 0, "Mock aeon server didn't stopped properly" + + +@pytest.fixture(params=["server-side", "mutual-tls"]) +def aeon_ssl(mock_aeon, certificates, request): + cmd = [ + mock_aeon, + "-ssl", + f"-key={certificates['s_private']}", + f"-cert={certificates['s_public']}", + ] + mode = request.param + if mode == "mutual-tls": + cmd.append(f"-ca={certificates['ca']}") + elif mode == "server-side": + pass + else: + assert False, "Unsupported TLS mode" + + aeon = Popen( + cmd, + env=dict(os.environ, GRPC_GO_LOG_SEVERITY_LEVEL="info"), + stderr=STDOUT, + stdout=PIPE, + text=True, + ) + print(wait_for_lines_in_output(aeon.stdout, ["ListenSocket created"])) + yield mode + aeon.send_signal(SIGQUIT) + assert aeon.wait(5) == 0, "Mock aeon ssl server didn't stopped properly" diff --git a/test/integration/aeon/generate-keys.sh b/test/integration/aeon/generate-keys.sh new file mode 100755 index 000000000..62970b895 --- /dev/null +++ b/test/integration/aeon/generate-keys.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -e + +### First argument is target directory where generate files. +DIR=$(realpath ${1:-$(pwd)}) +[ -d $DIR ] || mkdir -p $DIR +cd $DIR + +CA_SUBJ="/C=RU/ST=State/L=TestCity/O=Integration test/OU=Aeon/CN=localhost" + +cat > ext.cnf << EOF +subjectAltName = @alt_names +[alt_names] +DNS = localhost +IP = 127.0.0.1 +EOF + +### Server .key&.crt and ca.crt required for Server-Side TLS mode. + +# 1. Generate CA's private key and self-signed certificate +openssl req -new -x509 -days 1 -noenc -keyout ca.key -out ca.crt -subj "${CA_SUBJ}" -quiet + +# 2. Generate web server's private key and certificate signing request (CSR) +openssl req -new -noenc -keyout server.key -out server.csr -subj "${CA_SUBJ}" -quiet + +# 3. Use CA's private key to sign web server's CSR and get back the signed certificate +openssl x509 -req -in server.csr -days 1 -CA ca.crt -CAkey ca.key -CAcreateserial \ + -out server.crt -extfile ext.cnf + +### Client .key & .crt required for Mutual TSL mode. + +# 4. Generate client's private key and certificate signing request (CSR) +openssl req -new -noenc -keyout client.key -out client.csr -subj "$CA_SUBJ" -quiet + +# 5. Use CA's private key to sign client's CSR and get back the signed certificate +openssl x509 -req -in client.csr -days 1 -CA ca.crt -CAkey ca.key -CAcreateserial \ + -out client.crt -extfile ext.cnf diff --git a/test/integration/aeon/server/.gitignore b/test/integration/aeon/server/.gitignore new file mode 100644 index 000000000..29e4cb5e3 --- /dev/null +++ b/test/integration/aeon/server/.gitignore @@ -0,0 +1,2 @@ +*.proto +aeon \ No newline at end of file diff --git a/test/integration/aeon/server/README.md b/test/integration/aeon/server/README.md new file mode 100644 index 000000000..a9793436c --- /dev/null +++ b/test/integration/aeon/server/README.md @@ -0,0 +1,15 @@ +# Mock `aeon` server + +## Update and generate from `.proto` file + +1. cd `test/integration/aeon/server`; +2. Get a new [aeon_router.proto](https://github.com/tarantool/aeon/blob/master/proto/aeon_router.proto); +3. Run: `protoc --go_out=. --go-grpc_out=. aeon_router.proto`; +4. Directory `pb` will be created with files: +``` +pb +├── aeon_router_grpc.pb.go +└── aeon_router.pb.go +``` +5. Commit the new changes in the created files; +6. Update the `service/server.go` file to comply with the new `*.pb.go` requirements. diff --git a/test/integration/aeon/server/go.mod b/test/integration/aeon/server/go.mod new file mode 100644 index 000000000..ae916af9e --- /dev/null +++ b/test/integration/aeon/server/go.mod @@ -0,0 +1,15 @@ +module mock/server/aeon + +go 1.22.8 + +require ( + google.golang.org/grpc v1.68.1 + google.golang.org/protobuf v1.35.2 +) + +require ( + golang.org/x/net v0.29.0 // indirect + golang.org/x/sys v0.25.0 // indirect + golang.org/x/text v0.18.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect +) diff --git a/test/integration/aeon/server/go.sum b/test/integration/aeon/server/go.sum new file mode 100644 index 000000000..28968644c --- /dev/null +++ b/test/integration/aeon/server/go.sum @@ -0,0 +1,16 @@ +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= +golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= +golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= +golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224= +golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.68.1 h1:oI5oTa11+ng8r8XMMN7jAOmWfPZWbYpCFaMUTACxkM0= +google.golang.org/grpc v1.68.1/go.mod h1:+q1XYFJjShcqn0QZHvCyeR4CXPA+llXIeUIfIe00waw= +google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io= +google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= diff --git a/test/integration/aeon/server/mock.go b/test/integration/aeon/server/mock.go new file mode 100644 index 000000000..36e9afa56 --- /dev/null +++ b/test/integration/aeon/server/mock.go @@ -0,0 +1,139 @@ +package main + +import ( + "crypto/tls" + "crypto/x509" + "flag" + "fmt" + "log" + "mock/server/aeon/pb" + "mock/server/aeon/service" + "net" + "os" + "os/signal" + "strings" + "sync" + "syscall" + + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" +) + +var args = struct { + is_ssl *bool + ca_file *string + cert_file *string + key_file *string + port *int + unix_socket *string +}{ + is_ssl: flag.Bool("ssl", false, "Connection uses SSL if set, (default plain TCP)"), + ca_file: flag.String("ca", "", "The CA file"), + cert_file: flag.String("cert", "", "The TLS cert file"), + key_file: flag.String("key", "", "The TLS key file"), + port: flag.Int("port", 50051, "The server port"), + unix_socket: flag.String("unix", "", "The Unix socket name"), +} + +func getCertificate() tls.Certificate { + if *args.cert_file == "" || *args.key_file == "" { + log.Fatalln("Both 'key_file' and 'cert_file' required") + } + tls_cert, err := tls.LoadX509KeyPair(*args.cert_file, *args.key_file) + if err != nil { + log.Fatalf("Could not load server key pair: %v", err) + } + return tls_cert +} + +func getTlsConfig() *tls.Config { + if *args.ca_file == "" { + return &tls.Config{ + Certificates: []tls.Certificate{getCertificate()}, + ClientAuth: tls.NoClientCert, + } + } + + ca, err := os.ReadFile(*args.ca_file) + if err != nil { + log.Fatalf("Failed to read CA file: %v", err) + } + certPool := x509.NewCertPool() + if !certPool.AppendCertsFromPEM(ca) { + log.Fatalln("Failed to append CA data") + } + return &tls.Config{ + Certificates: []tls.Certificate{getCertificate()}, + ClientAuth: tls.RequireAndVerifyClientCert, + ClientCAs: certPool, + } +} + +func getServerOpts() []grpc.ServerOption { + if !*args.is_ssl { + return []grpc.ServerOption{} + } + creds := credentials.NewTLS(getTlsConfig()) + return []grpc.ServerOption{grpc.Creds(creds)} +} + +func getListener() net.Listener { + var protocol string + var address string + + if *args.unix_socket != "" { + protocol = "unix" + address = *args.unix_socket + if strings.HasPrefix(address, "@") { + address = "\x00" + address[1:] + } + } else { + protocol = "tcp" + address = fmt.Sprintf("localhost:%d", *args.port) + } + lis, err := net.Listen(protocol, address) + if err != nil { + log.Fatalf("Failed to listen: %v", err) + } + return lis +} + +func exit() { + log.Println("Exit func") + syscall.Kill(syscall.Getpid(), syscall.SIGTERM) + os.Exit(0) +} + +func main() { + log.Println("Start aeon mock server:", os.Args) + + flag.Parse() + + srv := grpc.NewServer(getServerOpts()...) + pb.RegisterAeonRouterServiceServer(srv, &service.Server{}) + + // Run gRPC server. + wg := sync.WaitGroup{} + wg.Add(1) + go func() { + if err := srv.Serve(getListener()); err != nil { + log.Fatalf("Failed to serve: %v", err) + } + wg.Done() + }() + + // Shutdown on signals. + exit_sig := make(chan os.Signal, 1) + signal.Notify(exit_sig, + syscall.SIGTERM, + syscall.SIGINT, + syscall.SIGQUIT, + syscall.SIGHUP, + ) + s := <-exit_sig + log.Println("Got terminate signal:", s) + + srv.GracefulStop() + wg.Wait() + log.Println("Exit aeon mock server.") +} diff --git a/test/integration/aeon/server/pb/aeon_router.pb.go b/test/integration/aeon/server/pb/aeon_router.pb.go new file mode 100644 index 000000000..4363aca8c --- /dev/null +++ b/test/integration/aeon/server/pb/aeon_router.pb.go @@ -0,0 +1,3557 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.35.2 +// protoc v5.28.3 +// source: aeon_router.proto + +package pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Special value denoting null. +type NullValue int32 + +const ( + NullValue_NULL_VALUE NullValue = 0 +) + +// Enum value maps for NullValue. +var ( + NullValue_name = map[int32]string{ + 0: "NULL_VALUE", + } + NullValue_value = map[string]int32{ + "NULL_VALUE": 0, + } +) + +func (x NullValue) Enum() *NullValue { + p := new(NullValue) + *p = x + return p +} + +func (x NullValue) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NullValue) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[0].Descriptor() +} + +func (NullValue) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[0] +} + +func (x NullValue) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NullValue.Descriptor instead. +func (NullValue) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{0} +} + +// Type a space field can have. +type FieldType int32 + +const ( + FieldType_FIELD_TYPE_UNSPECIFIED FieldType = 0 + FieldType_FIELD_TYPE_ANY FieldType = 1 + FieldType_FIELD_TYPE_UNSIGNED FieldType = 2 + FieldType_FIELD_TYPE_STRING FieldType = 3 + FieldType_FIELD_TYPE_NUMBER FieldType = 4 + FieldType_FIELD_TYPE_DOUBLE FieldType = 5 + FieldType_FIELD_TYPE_INTEGER FieldType = 6 + FieldType_FIELD_TYPE_BOOLEAN FieldType = 7 + FieldType_FIELD_TYPE_VARBINARY FieldType = 8 + FieldType_FIELD_TYPE_SCALAR FieldType = 9 + FieldType_FIELD_TYPE_DECIMAL FieldType = 10 + FieldType_FIELD_TYPE_UUID FieldType = 11 + FieldType_FIELD_TYPE_DATETIME FieldType = 12 + FieldType_FIELD_TYPE_INTERVAL FieldType = 13 + FieldType_FIELD_TYPE_ARRAY FieldType = 14 + FieldType_FIELD_TYPE_MAP FieldType = 15 +) + +// Enum value maps for FieldType. +var ( + FieldType_name = map[int32]string{ + 0: "FIELD_TYPE_UNSPECIFIED", + 1: "FIELD_TYPE_ANY", + 2: "FIELD_TYPE_UNSIGNED", + 3: "FIELD_TYPE_STRING", + 4: "FIELD_TYPE_NUMBER", + 5: "FIELD_TYPE_DOUBLE", + 6: "FIELD_TYPE_INTEGER", + 7: "FIELD_TYPE_BOOLEAN", + 8: "FIELD_TYPE_VARBINARY", + 9: "FIELD_TYPE_SCALAR", + 10: "FIELD_TYPE_DECIMAL", + 11: "FIELD_TYPE_UUID", + 12: "FIELD_TYPE_DATETIME", + 13: "FIELD_TYPE_INTERVAL", + 14: "FIELD_TYPE_ARRAY", + 15: "FIELD_TYPE_MAP", + } + FieldType_value = map[string]int32{ + "FIELD_TYPE_UNSPECIFIED": 0, + "FIELD_TYPE_ANY": 1, + "FIELD_TYPE_UNSIGNED": 2, + "FIELD_TYPE_STRING": 3, + "FIELD_TYPE_NUMBER": 4, + "FIELD_TYPE_DOUBLE": 5, + "FIELD_TYPE_INTEGER": 6, + "FIELD_TYPE_BOOLEAN": 7, + "FIELD_TYPE_VARBINARY": 8, + "FIELD_TYPE_SCALAR": 9, + "FIELD_TYPE_DECIMAL": 10, + "FIELD_TYPE_UUID": 11, + "FIELD_TYPE_DATETIME": 12, + "FIELD_TYPE_INTERVAL": 13, + "FIELD_TYPE_ARRAY": 14, + "FIELD_TYPE_MAP": 15, + } +) + +func (x FieldType) Enum() *FieldType { + p := new(FieldType) + *p = x + return p +} + +func (x FieldType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldType) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[1].Descriptor() +} + +func (FieldType) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[1] +} + +func (x FieldType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use FieldType.Descriptor instead. +func (FieldType) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{1} +} + +type SelectIterator int32 + +const ( + SelectIterator_SELECT_ITERATOR_GT SelectIterator = 0 + SelectIterator_SELECT_ITERATOR_GE SelectIterator = 1 + SelectIterator_SELECT_ITERATOR_LT SelectIterator = 2 + SelectIterator_SELECT_ITERATOR_LE SelectIterator = 3 + SelectIterator_SELECT_ITERATOR_PP SelectIterator = 4 + SelectIterator_SELECT_ITERATOR_NP SelectIterator = 5 +) + +// Enum value maps for SelectIterator. +var ( + SelectIterator_name = map[int32]string{ + 0: "SELECT_ITERATOR_GT", + 1: "SELECT_ITERATOR_GE", + 2: "SELECT_ITERATOR_LT", + 3: "SELECT_ITERATOR_LE", + 4: "SELECT_ITERATOR_PP", + 5: "SELECT_ITERATOR_NP", + } + SelectIterator_value = map[string]int32{ + "SELECT_ITERATOR_GT": 0, + "SELECT_ITERATOR_GE": 1, + "SELECT_ITERATOR_LT": 2, + "SELECT_ITERATOR_LE": 3, + "SELECT_ITERATOR_PP": 4, + "SELECT_ITERATOR_NP": 5, + } +) + +func (x SelectIterator) Enum() *SelectIterator { + p := new(SelectIterator) + *p = x + return p +} + +func (x SelectIterator) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SelectIterator) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[2].Descriptor() +} + +func (SelectIterator) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[2] +} + +func (x SelectIterator) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SelectIterator.Descriptor instead. +func (SelectIterator) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{2} +} + +type SQLCheckStatus int32 + +const ( + SQLCheckStatus_SQL_QUERY_VALID SQLCheckStatus = 0 + SQLCheckStatus_SQL_QUERY_INCOMPLETE SQLCheckStatus = 1 + SQLCheckStatus_SQL_QUERY_INVALID SQLCheckStatus = 2 +) + +// Enum value maps for SQLCheckStatus. +var ( + SQLCheckStatus_name = map[int32]string{ + 0: "SQL_QUERY_VALID", + 1: "SQL_QUERY_INCOMPLETE", + 2: "SQL_QUERY_INVALID", + } + SQLCheckStatus_value = map[string]int32{ + "SQL_QUERY_VALID": 0, + "SQL_QUERY_INCOMPLETE": 1, + "SQL_QUERY_INVALID": 2, + } +) + +func (x SQLCheckStatus) Enum() *SQLCheckStatus { + p := new(SQLCheckStatus) + *p = x + return p +} + +func (x SQLCheckStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SQLCheckStatus) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[3].Descriptor() +} + +func (SQLCheckStatus) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[3] +} + +func (x SQLCheckStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SQLCheckStatus.Descriptor instead. +func (SQLCheckStatus) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{3} +} + +type IntervalValue_IntervalAdjust int32 + +const ( + IntervalValue_INTERVAL_ADJUST_NONE IntervalValue_IntervalAdjust = 0 + IntervalValue_INTERVAL_ADJUST_EXCESS IntervalValue_IntervalAdjust = 1 + IntervalValue_INTERVAL_ADJUST_LAST IntervalValue_IntervalAdjust = 2 +) + +// Enum value maps for IntervalValue_IntervalAdjust. +var ( + IntervalValue_IntervalAdjust_name = map[int32]string{ + 0: "INTERVAL_ADJUST_NONE", + 1: "INTERVAL_ADJUST_EXCESS", + 2: "INTERVAL_ADJUST_LAST", + } + IntervalValue_IntervalAdjust_value = map[string]int32{ + "INTERVAL_ADJUST_NONE": 0, + "INTERVAL_ADJUST_EXCESS": 1, + "INTERVAL_ADJUST_LAST": 2, + } +) + +func (x IntervalValue_IntervalAdjust) Enum() *IntervalValue_IntervalAdjust { + p := new(IntervalValue_IntervalAdjust) + *p = x + return p +} + +func (x IntervalValue_IntervalAdjust) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (IntervalValue_IntervalAdjust) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[4].Descriptor() +} + +func (IntervalValue_IntervalAdjust) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[4] +} + +func (x IntervalValue_IntervalAdjust) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use IntervalValue_IntervalAdjust.Descriptor instead. +func (IntervalValue_IntervalAdjust) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{3, 0} +} + +type KeyPartDef_KeyPartSortOrder int32 + +const ( + KeyPartDef_KEY_PART_SORT_ORDER_ASC KeyPartDef_KeyPartSortOrder = 0 + KeyPartDef_KEY_PART_SORT_ORDER_DESC KeyPartDef_KeyPartSortOrder = 1 +) + +// Enum value maps for KeyPartDef_KeyPartSortOrder. +var ( + KeyPartDef_KeyPartSortOrder_name = map[int32]string{ + 0: "KEY_PART_SORT_ORDER_ASC", + 1: "KEY_PART_SORT_ORDER_DESC", + } + KeyPartDef_KeyPartSortOrder_value = map[string]int32{ + "KEY_PART_SORT_ORDER_ASC": 0, + "KEY_PART_SORT_ORDER_DESC": 1, + } +) + +func (x KeyPartDef_KeyPartSortOrder) Enum() *KeyPartDef_KeyPartSortOrder { + p := new(KeyPartDef_KeyPartSortOrder) + *p = x + return p +} + +func (x KeyPartDef_KeyPartSortOrder) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (KeyPartDef_KeyPartSortOrder) Descriptor() protoreflect.EnumDescriptor { + return file_aeon_router_proto_enumTypes[5].Descriptor() +} + +func (KeyPartDef_KeyPartSortOrder) Type() protoreflect.EnumType { + return &file_aeon_router_proto_enumTypes[5] +} + +func (x KeyPartDef_KeyPartSortOrder) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use KeyPartDef_KeyPartSortOrder.Descriptor instead. +func (KeyPartDef_KeyPartSortOrder) EnumDescriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{10, 0} +} + +// Array of arbitrary-typed values. +type ArrayValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Fields []*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"` +} + +func (x *ArrayValue) Reset() { + *x = ArrayValue{} + mi := &file_aeon_router_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ArrayValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArrayValue) ProtoMessage() {} + +func (x *ArrayValue) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ArrayValue.ProtoReflect.Descriptor instead. +func (*ArrayValue) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{0} +} + +func (x *ArrayValue) GetFields() []*Value { + if x != nil { + return x.Fields + } + return nil +} + +// Map with string keys and arbitrary-typed values.. +type MapValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *MapValue) Reset() { + *x = MapValue{} + mi := &file_aeon_router_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MapValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MapValue) ProtoMessage() {} + +func (x *MapValue) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MapValue.ProtoReflect.Descriptor instead. +func (*MapValue) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{1} +} + +func (x *MapValue) GetFields() map[string]*Value { + if x != nil { + return x.Fields + } + return nil +} + +// Date time value. +type DateTimeValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` + Nsec int64 `protobuf:"varint,2,opt,name=nsec,proto3" json:"nsec,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` +} + +func (x *DateTimeValue) Reset() { + *x = DateTimeValue{} + mi := &file_aeon_router_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DateTimeValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DateTimeValue) ProtoMessage() {} + +func (x *DateTimeValue) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DateTimeValue.ProtoReflect.Descriptor instead. +func (*DateTimeValue) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{2} +} + +func (x *DateTimeValue) GetSeconds() int64 { + if x != nil { + return x.Seconds + } + return 0 +} + +func (x *DateTimeValue) GetNsec() int64 { + if x != nil { + return x.Nsec + } + return 0 +} + +func (x *DateTimeValue) GetLocation() string { + if x != nil { + return x.Location + } + return "" +} + +// Date time interval value. +type IntervalValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Year int64 `protobuf:"varint,1,opt,name=year,proto3" json:"year,omitempty"` + Month int64 `protobuf:"varint,2,opt,name=month,proto3" json:"month,omitempty"` + Week int64 `protobuf:"varint,3,opt,name=week,proto3" json:"week,omitempty"` + Day int64 `protobuf:"varint,4,opt,name=day,proto3" json:"day,omitempty"` + Hour int64 `protobuf:"varint,5,opt,name=hour,proto3" json:"hour,omitempty"` + Min int64 `protobuf:"varint,6,opt,name=min,proto3" json:"min,omitempty"` + Sec int64 `protobuf:"varint,7,opt,name=sec,proto3" json:"sec,omitempty"` + Nsec int64 `protobuf:"varint,8,opt,name=nsec,proto3" json:"nsec,omitempty"` + Adjust IntervalValue_IntervalAdjust `protobuf:"varint,9,opt,name=adjust,proto3,enum=aeon_router.IntervalValue_IntervalAdjust" json:"adjust,omitempty"` +} + +func (x *IntervalValue) Reset() { + *x = IntervalValue{} + mi := &file_aeon_router_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IntervalValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IntervalValue) ProtoMessage() {} + +func (x *IntervalValue) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IntervalValue.ProtoReflect.Descriptor instead. +func (*IntervalValue) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{3} +} + +func (x *IntervalValue) GetYear() int64 { + if x != nil { + return x.Year + } + return 0 +} + +func (x *IntervalValue) GetMonth() int64 { + if x != nil { + return x.Month + } + return 0 +} + +func (x *IntervalValue) GetWeek() int64 { + if x != nil { + return x.Week + } + return 0 +} + +func (x *IntervalValue) GetDay() int64 { + if x != nil { + return x.Day + } + return 0 +} + +func (x *IntervalValue) GetHour() int64 { + if x != nil { + return x.Hour + } + return 0 +} + +func (x *IntervalValue) GetMin() int64 { + if x != nil { + return x.Min + } + return 0 +} + +func (x *IntervalValue) GetSec() int64 { + if x != nil { + return x.Sec + } + return 0 +} + +func (x *IntervalValue) GetNsec() int64 { + if x != nil { + return x.Nsec + } + return 0 +} + +func (x *IntervalValue) GetAdjust() IntervalValue_IntervalAdjust { + if x != nil { + return x.Adjust + } + return IntervalValue_INTERVAL_ADJUST_NONE +} + +// Arbitrary value that can be serialized to be sent over the network or +// stored in the database. +type Value struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Kind: + // + // *Value_UnsignedValue + // *Value_StringValue + // *Value_NumberValue + // *Value_IntegerValue + // *Value_BooleanValue + // *Value_VarbinaryValue + // *Value_DecimalValue + // *Value_UuidValue + // *Value_DatetimeValue + // *Value_IntervalValue + // *Value_ArrayValue + // *Value_MapValue + // *Value_NullValue + Kind isValue_Kind `protobuf_oneof:"kind"` +} + +func (x *Value) Reset() { + *x = Value{} + mi := &file_aeon_router_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Value) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Value) ProtoMessage() {} + +func (x *Value) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Value.ProtoReflect.Descriptor instead. +func (*Value) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{4} +} + +func (m *Value) GetKind() isValue_Kind { + if m != nil { + return m.Kind + } + return nil +} + +func (x *Value) GetUnsignedValue() uint64 { + if x, ok := x.GetKind().(*Value_UnsignedValue); ok { + return x.UnsignedValue + } + return 0 +} + +func (x *Value) GetStringValue() string { + if x, ok := x.GetKind().(*Value_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *Value) GetNumberValue() float64 { + if x, ok := x.GetKind().(*Value_NumberValue); ok { + return x.NumberValue + } + return 0 +} + +func (x *Value) GetIntegerValue() int64 { + if x, ok := x.GetKind().(*Value_IntegerValue); ok { + return x.IntegerValue + } + return 0 +} + +func (x *Value) GetBooleanValue() bool { + if x, ok := x.GetKind().(*Value_BooleanValue); ok { + return x.BooleanValue + } + return false +} + +func (x *Value) GetVarbinaryValue() []byte { + if x, ok := x.GetKind().(*Value_VarbinaryValue); ok { + return x.VarbinaryValue + } + return nil +} + +func (x *Value) GetDecimalValue() string { + if x, ok := x.GetKind().(*Value_DecimalValue); ok { + return x.DecimalValue + } + return "" +} + +func (x *Value) GetUuidValue() string { + if x, ok := x.GetKind().(*Value_UuidValue); ok { + return x.UuidValue + } + return "" +} + +func (x *Value) GetDatetimeValue() *DateTimeValue { + if x, ok := x.GetKind().(*Value_DatetimeValue); ok { + return x.DatetimeValue + } + return nil +} + +func (x *Value) GetIntervalValue() *IntervalValue { + if x, ok := x.GetKind().(*Value_IntervalValue); ok { + return x.IntervalValue + } + return nil +} + +func (x *Value) GetArrayValue() *ArrayValue { + if x, ok := x.GetKind().(*Value_ArrayValue); ok { + return x.ArrayValue + } + return nil +} + +func (x *Value) GetMapValue() *MapValue { + if x, ok := x.GetKind().(*Value_MapValue); ok { + return x.MapValue + } + return nil +} + +func (x *Value) GetNullValue() NullValue { + if x, ok := x.GetKind().(*Value_NullValue); ok { + return x.NullValue + } + return NullValue_NULL_VALUE +} + +type isValue_Kind interface { + isValue_Kind() +} + +type Value_UnsignedValue struct { + UnsignedValue uint64 `protobuf:"varint,1,opt,name=unsigned_value,json=unsignedValue,proto3,oneof"` +} + +type Value_StringValue struct { + StringValue string `protobuf:"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof"` +} + +type Value_NumberValue struct { + NumberValue float64 `protobuf:"fixed64,3,opt,name=number_value,json=numberValue,proto3,oneof"` +} + +type Value_IntegerValue struct { + IntegerValue int64 `protobuf:"zigzag64,4,opt,name=integer_value,json=integerValue,proto3,oneof"` +} + +type Value_BooleanValue struct { + BooleanValue bool `protobuf:"varint,5,opt,name=boolean_value,json=booleanValue,proto3,oneof"` +} + +type Value_VarbinaryValue struct { + VarbinaryValue []byte `protobuf:"bytes,6,opt,name=varbinary_value,json=varbinaryValue,proto3,oneof"` +} + +type Value_DecimalValue struct { + DecimalValue string `protobuf:"bytes,7,opt,name=decimal_value,json=decimalValue,proto3,oneof"` +} + +type Value_UuidValue struct { + UuidValue string `protobuf:"bytes,8,opt,name=uuid_value,json=uuidValue,proto3,oneof"` +} + +type Value_DatetimeValue struct { + DatetimeValue *DateTimeValue `protobuf:"bytes,9,opt,name=datetime_value,json=datetimeValue,proto3,oneof"` +} + +type Value_IntervalValue struct { + IntervalValue *IntervalValue `protobuf:"bytes,10,opt,name=interval_value,json=intervalValue,proto3,oneof"` +} + +type Value_ArrayValue struct { + ArrayValue *ArrayValue `protobuf:"bytes,11,opt,name=array_value,json=arrayValue,proto3,oneof"` +} + +type Value_MapValue struct { + MapValue *MapValue `protobuf:"bytes,12,opt,name=map_value,json=mapValue,proto3,oneof"` +} + +type Value_NullValue struct { + NullValue NullValue `protobuf:"varint,13,opt,name=null_value,json=nullValue,proto3,enum=aeon_router.NullValue,oneof"` +} + +func (*Value_UnsignedValue) isValue_Kind() {} + +func (*Value_StringValue) isValue_Kind() {} + +func (*Value_NumberValue) isValue_Kind() {} + +func (*Value_IntegerValue) isValue_Kind() {} + +func (*Value_BooleanValue) isValue_Kind() {} + +func (*Value_VarbinaryValue) isValue_Kind() {} + +func (*Value_DecimalValue) isValue_Kind() {} + +func (*Value_UuidValue) isValue_Kind() {} + +func (*Value_DatetimeValue) isValue_Kind() {} + +func (*Value_IntervalValue) isValue_Kind() {} + +func (*Value_ArrayValue) isValue_Kind() {} + +func (*Value_MapValue) isValue_Kind() {} + +func (*Value_NullValue) isValue_Kind() {} + +// Error information. +type Error struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error type. + // * AeonError for core Aeon errors. + // * AeonSQLError for issues with SQL parsing. + // * AeonGRPCError for issues with gRPC encoding. + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // Error name. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // Error location: file, line. + File string `protobuf:"bytes,3,opt,name=file,proto3" json:"file,omitempty"` + Line uint64 `protobuf:"varint,4,opt,name=line,proto3" json:"line,omitempty"` + // Human-readable error description. + Msg string `protobuf:"bytes,5,opt,name=msg,proto3" json:"msg,omitempty"` + // System errno (usually not set). + Errno uint64 `protobuf:"varint,6,opt,name=errno,proto3" json:"errno,omitempty"` + // Error code. + Code uint64 `protobuf:"varint,7,opt,name=code,proto3" json:"code,omitempty"` + // Fields with extra information. + Fields *MapValue `protobuf:"bytes,8,opt,name=fields,proto3" json:"fields,omitempty"` + // Previous error on the error stack (cause of this error). + Prev *Error `protobuf:"bytes,9,opt,name=prev,proto3" json:"prev,omitempty"` +} + +func (x *Error) Reset() { + *x = Error{} + mi := &file_aeon_router_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Error) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Error) ProtoMessage() {} + +func (x *Error) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Error.ProtoReflect.Descriptor instead. +func (*Error) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{5} +} + +func (x *Error) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *Error) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Error) GetFile() string { + if x != nil { + return x.File + } + return "" +} + +func (x *Error) GetLine() uint64 { + if x != nil { + return x.Line + } + return 0 +} + +func (x *Error) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *Error) GetErrno() uint64 { + if x != nil { + return x.Errno + } + return 0 +} + +func (x *Error) GetCode() uint64 { + if x != nil { + return x.Code + } + return 0 +} + +func (x *Error) GetFields() *MapValue { + if x != nil { + return x.Fields + } + return nil +} + +func (x *Error) GetPrev() *Error { + if x != nil { + return x.Prev + } + return nil +} + +// Tuple: array of values. +type Tuple struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Fields []*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"` +} + +func (x *Tuple) Reset() { + *x = Tuple{} + mi := &file_aeon_router_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Tuple) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Tuple) ProtoMessage() {} + +func (x *Tuple) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Tuple.ProtoReflect.Descriptor instead. +func (*Tuple) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{6} +} + +func (x *Tuple) GetFields() []*Value { + if x != nil { + return x.Fields + } + return nil +} + +// Tuple format: array of field names. +type TupleFormat struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"` +} + +func (x *TupleFormat) Reset() { + *x = TupleFormat{} + mi := &file_aeon_router_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TupleFormat) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TupleFormat) ProtoMessage() {} + +func (x *TupleFormat) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TupleFormat.ProtoReflect.Descriptor instead. +func (*TupleFormat) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{7} +} + +func (x *TupleFormat) GetNames() []string { + if x != nil { + return x.Names + } + return nil +} + +// Read or write operation executed in a transaction. +type Operation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Target key in the space. Must be full (have all defined key parts). + Key *Tuple `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // In a request: + // * Ignored for read operations. + // * Specifies the tuple to write in a write operation. + // In a response: + // * Tuple read from or written to the target space. + // The write operation type depends on the tuple value: + // * NOP if the tuple is not set. + // * DELETE if the tuple is set but has no fields. + // * REPLACE otherwise. The tuple must match the target key. + // The tuple may be overwritten by the user-defined function specified in + // a request to change the written value or even operation type depending on + // read values. + Tuple *Tuple `protobuf:"bytes,3,opt,name=tuple,proto3" json:"tuple,omitempty"` +} + +func (x *Operation) Reset() { + *x = Operation{} + mi := &file_aeon_router_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Operation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Operation) ProtoMessage() {} + +func (x *Operation) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Operation.ProtoReflect.Descriptor instead. +func (*Operation) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{8} +} + +func (x *Operation) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *Operation) GetKey() *Tuple { + if x != nil { + return x.Key + } + return nil +} + +func (x *Operation) GetTuple() *Tuple { + if x != nil { + return x.Tuple + } + return nil +} + +// Space field definition. +type FieldDef struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Field name. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Field type. + Type FieldType `protobuf:"varint,2,opt,name=type,proto3,enum=aeon_router.FieldType" json:"type,omitempty"` + // If set to true, the field may store null values. Optional. + IsNullable bool `protobuf:"varint,3,opt,name=is_nullable,json=isNullable,proto3" json:"is_nullable,omitempty"` +} + +func (x *FieldDef) Reset() { + *x = FieldDef{} + mi := &file_aeon_router_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FieldDef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FieldDef) ProtoMessage() {} + +func (x *FieldDef) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FieldDef.ProtoReflect.Descriptor instead. +func (*FieldDef) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{9} +} + +func (x *FieldDef) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *FieldDef) GetType() FieldType { + if x != nil { + return x.Type + } + return FieldType_FIELD_TYPE_UNSPECIFIED +} + +func (x *FieldDef) GetIsNullable() bool { + if x != nil { + return x.IsNullable + } + return false +} + +// Key part definition. +type KeyPartDef struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Indexed field ordinal number (1-based) or name. + // + // Types that are assignable to Field: + // + // *KeyPartDef_Id + // *KeyPartDef_Name + Field isKeyPartDef_Field `protobuf_oneof:"field"` + // Key part type. Optional: if omitted, it will be deduced from + // the corresponding space field type. + Type FieldType `protobuf:"varint,3,opt,name=type,proto3,enum=aeon_router.FieldType" json:"type,omitempty"` + // Sorting order: ascending (default) or descending. + SortOrder KeyPartDef_KeyPartSortOrder `protobuf:"varint,4,opt,name=sort_order,json=sortOrder,proto3,enum=aeon_router.KeyPartDef_KeyPartSortOrder" json:"sort_order,omitempty"` +} + +func (x *KeyPartDef) Reset() { + *x = KeyPartDef{} + mi := &file_aeon_router_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *KeyPartDef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeyPartDef) ProtoMessage() {} + +func (x *KeyPartDef) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use KeyPartDef.ProtoReflect.Descriptor instead. +func (*KeyPartDef) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{10} +} + +func (m *KeyPartDef) GetField() isKeyPartDef_Field { + if m != nil { + return m.Field + } + return nil +} + +func (x *KeyPartDef) GetId() uint64 { + if x, ok := x.GetField().(*KeyPartDef_Id); ok { + return x.Id + } + return 0 +} + +func (x *KeyPartDef) GetName() string { + if x, ok := x.GetField().(*KeyPartDef_Name); ok { + return x.Name + } + return "" +} + +func (x *KeyPartDef) GetType() FieldType { + if x != nil { + return x.Type + } + return FieldType_FIELD_TYPE_UNSPECIFIED +} + +func (x *KeyPartDef) GetSortOrder() KeyPartDef_KeyPartSortOrder { + if x != nil { + return x.SortOrder + } + return KeyPartDef_KEY_PART_SORT_ORDER_ASC +} + +type isKeyPartDef_Field interface { + isKeyPartDef_Field() +} + +type KeyPartDef_Id struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3,oneof"` +} + +type KeyPartDef_Name struct { + Name string `protobuf:"bytes,2,opt,name=name,proto3,oneof"` +} + +func (*KeyPartDef_Id) isKeyPartDef_Field() {} + +func (*KeyPartDef_Name) isKeyPartDef_Field() {} + +type PingRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *PingRequest) Reset() { + *x = PingRequest{} + mi := &file_aeon_router_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PingRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingRequest) ProtoMessage() {} + +func (x *PingRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PingRequest.ProtoReflect.Descriptor instead. +func (*PingRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{11} +} + +type PingResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` +} + +func (x *PingResponse) Reset() { + *x = PingResponse{} + mi := &file_aeon_router_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PingResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingResponse) ProtoMessage() {} + +func (x *PingResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PingResponse.ProtoReflect.Descriptor instead. +func (*PingResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{12} +} + +func (x *PingResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +type CreateSpaceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the new space. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Format of the new space. + Format []*FieldDef `protobuf:"bytes,2,rep,name=format,proto3" json:"format,omitempty"` + // Sorting key definition (indexed fields). + KeyDef []*KeyPartDef `protobuf:"bytes,3,rep,name=key_def,json=keyDef,proto3" json:"key_def,omitempty"` +} + +func (x *CreateSpaceRequest) Reset() { + *x = CreateSpaceRequest{} + mi := &file_aeon_router_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSpaceRequest) ProtoMessage() {} + +func (x *CreateSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSpaceRequest.ProtoReflect.Descriptor instead. +func (*CreateSpaceRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{13} +} + +func (x *CreateSpaceRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *CreateSpaceRequest) GetFormat() []*FieldDef { + if x != nil { + return x.Format + } + return nil +} + +func (x *CreateSpaceRequest) GetKeyDef() []*KeyPartDef { + if x != nil { + return x.KeyDef + } + return nil +} + +type CreateSpaceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` +} + +func (x *CreateSpaceResponse) Reset() { + *x = CreateSpaceResponse{} + mi := &file_aeon_router_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSpaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSpaceResponse) ProtoMessage() {} + +func (x *CreateSpaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSpaceResponse.ProtoReflect.Descriptor instead. +func (*CreateSpaceResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{14} +} + +func (x *CreateSpaceResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +type DropSpaceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Name of the space to drop. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *DropSpaceRequest) Reset() { + *x = DropSpaceRequest{} + mi := &file_aeon_router_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DropSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DropSpaceRequest) ProtoMessage() {} + +func (x *DropSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DropSpaceRequest.ProtoReflect.Descriptor instead. +func (*DropSpaceRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{15} +} + +func (x *DropSpaceRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type DropSpaceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` +} + +func (x *DropSpaceResponse) Reset() { + *x = DropSpaceResponse{} + mi := &file_aeon_router_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DropSpaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DropSpaceResponse) ProtoMessage() {} + +func (x *DropSpaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DropSpaceResponse.ProtoReflect.Descriptor instead. +func (*DropSpaceResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{16} +} + +func (x *DropSpaceResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +type ExecuteRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Array of read operations. + ReadSet []*Operation `protobuf:"bytes,1,rep,name=read_set,json=readSet,proto3" json:"read_set,omitempty"` + // Array of write operations. + WriteSet []*Operation `protobuf:"bytes,2,rep,name=write_set,json=writeSet,proto3" json:"write_set,omitempty"` + // Source code of a Lua function that will be used to update the write + // operations. It's optional: if not set, the write operations will be + // executed as is. + // + // The function is passed three arguments: the read set with filled tuples, + // the original write set, and the optional extra argument set by the caller + // (see below). If the function raises an error, the transaction will be + // aborted, otherwise it will apply the write set. The function may update + // the tuples in write operations (in-place), but it may not add or delete + // operations or update the target spaces or keys. + // + // A read/write operation is passed in an array: {space, key, tuple}. + // (without string key names). + // + // Below is an example of a Lua function that inserts tuples only if there + // are no tuples with the same keys, otherwise returns the existing tuples. + // It's supposed to be passed read and write sets with the same keys. + // + // function(read_set, write_set, flags) + // + // local exists = {} + // for _, op in pairs(read_set) do + // if op[3] ~= nil then + // table.insert(exists, op[3]) + // end + // end + // if #exists > 0 then + // for _, op in pairs(write_set) do + // op[3] = nil + // end + // end + // return {exists = exists} + // + // end + Func string `protobuf:"bytes,3,opt,name=func,proto3" json:"func,omitempty"` + // Argument passed to the user-defined function. Optional. + FuncArg *Value `protobuf:"bytes,4,opt,name=func_arg,json=funcArg,proto3" json:"func_arg,omitempty"` + // Map : space name -> key format. + // Contains formats of all provided keys. Optional. + KeyFormats map[string]*TupleFormat `protobuf:"bytes,5,rep,name=key_formats,json=keyFormats,proto3" json:"key_formats,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Map : space name -> tuple format. + // Contains formats of all provided tuples. Optional. + TupleFormats map[string]*TupleFormat `protobuf:"bytes,6,rep,name=tuple_formats,json=tupleFormats,proto3" json:"tuple_formats,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ExecuteRequest) Reset() { + *x = ExecuteRequest{} + mi := &file_aeon_router_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecuteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecuteRequest) ProtoMessage() {} + +func (x *ExecuteRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecuteRequest.ProtoReflect.Descriptor instead. +func (*ExecuteRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{17} +} + +func (x *ExecuteRequest) GetReadSet() []*Operation { + if x != nil { + return x.ReadSet + } + return nil +} + +func (x *ExecuteRequest) GetWriteSet() []*Operation { + if x != nil { + return x.WriteSet + } + return nil +} + +func (x *ExecuteRequest) GetFunc() string { + if x != nil { + return x.Func + } + return "" +} + +func (x *ExecuteRequest) GetFuncArg() *Value { + if x != nil { + return x.FuncArg + } + return nil +} + +func (x *ExecuteRequest) GetKeyFormats() map[string]*TupleFormat { + if x != nil { + return x.KeyFormats + } + return nil +} + +func (x *ExecuteRequest) GetTupleFormats() map[string]*TupleFormat { + if x != nil { + return x.TupleFormats + } + return nil +} + +type ExecuteResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Array of executed read operations (with filled tuples). + ReadSet []*Operation `protobuf:"bytes,2,rep,name=read_set,json=readSet,proto3" json:"read_set,omitempty"` + // Array of executed write operations (updated by the user-defined function). + WriteSet []*Operation `protobuf:"bytes,3,rep,name=write_set,json=writeSet,proto3" json:"write_set,omitempty"` + // Value returned by the user-defined function. + FuncRet *Value `protobuf:"bytes,4,opt,name=func_ret,json=funcRet,proto3" json:"func_ret,omitempty"` + // Map : space name -> tuple format. + // Contains formats of all returned tuples. + TupleFormats map[string]*TupleFormat `protobuf:"bytes,5,rep,name=tuple_formats,json=tupleFormats,proto3" json:"tuple_formats,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *ExecuteResponse) Reset() { + *x = ExecuteResponse{} + mi := &file_aeon_router_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecuteResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecuteResponse) ProtoMessage() {} + +func (x *ExecuteResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecuteResponse.ProtoReflect.Descriptor instead. +func (*ExecuteResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{18} +} + +func (x *ExecuteResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *ExecuteResponse) GetReadSet() []*Operation { + if x != nil { + return x.ReadSet + } + return nil +} + +func (x *ExecuteResponse) GetWriteSet() []*Operation { + if x != nil { + return x.WriteSet + } + return nil +} + +func (x *ExecuteResponse) GetFuncRet() *Value { + if x != nil { + return x.FuncRet + } + return nil +} + +func (x *ExecuteResponse) GetTupleFormats() map[string]*TupleFormat { + if x != nil { + return x.TupleFormats + } + return nil +} + +type InsertRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Tuples to insert into the space. + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Optional flags, see above. + Flags *InsertRequest_InsertFlags `protobuf:"bytes,3,opt,name=flags,proto3" json:"flags,omitempty"` + // Format of the provided tuples. Optional. + TupleFormat *TupleFormat `protobuf:"bytes,4,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *InsertRequest) Reset() { + *x = InsertRequest{} + mi := &file_aeon_router_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InsertRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InsertRequest) ProtoMessage() {} + +func (x *InsertRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InsertRequest.ProtoReflect.Descriptor instead. +func (*InsertRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{19} +} + +func (x *InsertRequest) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *InsertRequest) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *InsertRequest) GetFlags() *InsertRequest_InsertFlags { + if x != nil { + return x.Flags + } + return nil +} + +func (x *InsertRequest) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type InsertResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Inserted (new) tuples (only if return_tuples flag was set). + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,3,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *InsertResponse) Reset() { + *x = InsertResponse{} + mi := &file_aeon_router_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InsertResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InsertResponse) ProtoMessage() {} + +func (x *InsertResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InsertResponse.ProtoReflect.Descriptor instead. +func (*InsertResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{20} +} + +func (x *InsertResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *InsertResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *InsertResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type ReplaceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Tuple to replace in the space. + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Optional flags, see above. + Flags *ReplaceRequest_ReplaceFlags `protobuf:"bytes,3,opt,name=flags,proto3" json:"flags,omitempty"` + // Format of the provided tuples. Optional. + TupleFormat *TupleFormat `protobuf:"bytes,4,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *ReplaceRequest) Reset() { + *x = ReplaceRequest{} + mi := &file_aeon_router_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplaceRequest) ProtoMessage() {} + +func (x *ReplaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplaceRequest.ProtoReflect.Descriptor instead. +func (*ReplaceRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{21} +} + +func (x *ReplaceRequest) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *ReplaceRequest) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *ReplaceRequest) GetFlags() *ReplaceRequest_ReplaceFlags { + if x != nil { + return x.Flags + } + return nil +} + +func (x *ReplaceRequest) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type ReplaceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Inserted (new) tuples (only if return_tuples flag was set). + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,3,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *ReplaceResponse) Reset() { + *x = ReplaceResponse{} + mi := &file_aeon_router_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplaceResponse) ProtoMessage() {} + +func (x *ReplaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplaceResponse.ProtoReflect.Descriptor instead. +func (*ReplaceResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{22} +} + +func (x *ReplaceResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *ReplaceResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *ReplaceResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type DeleteRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Keys to delete from the space. + Keys []*Tuple `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + // Optional flags, see above. + Flags *DeleteRequest_DeleteFlags `protobuf:"bytes,3,opt,name=flags,proto3" json:"flags,omitempty"` + // Format of the provided keys. Optional. + KeyFormat *TupleFormat `protobuf:"bytes,4,opt,name=key_format,json=keyFormat,proto3" json:"key_format,omitempty"` +} + +func (x *DeleteRequest) Reset() { + *x = DeleteRequest{} + mi := &file_aeon_router_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteRequest) ProtoMessage() {} + +func (x *DeleteRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteRequest.ProtoReflect.Descriptor instead. +func (*DeleteRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{23} +} + +func (x *DeleteRequest) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *DeleteRequest) GetKeys() []*Tuple { + if x != nil { + return x.Keys + } + return nil +} + +func (x *DeleteRequest) GetFlags() *DeleteRequest_DeleteFlags { + if x != nil { + return x.Flags + } + return nil +} + +func (x *DeleteRequest) GetKeyFormat() *TupleFormat { + if x != nil { + return x.KeyFormat + } + return nil +} + +type DeleteResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Deleted (old) tuples (only if return_tuples flag was set). + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,3,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *DeleteResponse) Reset() { + *x = DeleteResponse{} + mi := &file_aeon_router_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteResponse) ProtoMessage() {} + +func (x *DeleteResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteResponse.ProtoReflect.Descriptor instead. +func (*DeleteResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{24} +} + +func (x *DeleteResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *DeleteResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *DeleteResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type GetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Keys to query from the space. + Keys []*Tuple `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + // Format of the provided keys. Optional. + KeyFormat *TupleFormat `protobuf:"bytes,3,opt,name=key_format,json=keyFormat,proto3" json:"key_format,omitempty"` +} + +func (x *GetRequest) Reset() { + *x = GetRequest{} + mi := &file_aeon_router_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRequest) ProtoMessage() {} + +func (x *GetRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead. +func (*GetRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{25} +} + +func (x *GetRequest) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *GetRequest) GetKeys() []*Tuple { + if x != nil { + return x.Keys + } + return nil +} + +func (x *GetRequest) GetKeyFormat() *TupleFormat { + if x != nil { + return x.KeyFormat + } + return nil +} + +type GetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Retrieved tuples. + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,3,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *GetResponse) Reset() { + *x = GetResponse{} + mi := &file_aeon_router_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResponse) ProtoMessage() {} + +func (x *GetResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetResponse.ProtoReflect.Descriptor instead. +func (*GetResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{26} +} + +func (x *GetResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *GetResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *GetResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type SelectRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Target space name. + Space string `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Key or partial key to query from the space. + Key *Tuple `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // The type of iterator to use in the select. + Iterator SelectIterator `protobuf:"varint,3,opt,name=iterator,proto3,enum=aeon_router.SelectIterator" json:"iterator,omitempty"` + // Max number of tuples to return. + Limit uint64 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` + // Max number of function calls allowed. + CallsLimit uint64 `protobuf:"varint,5,opt,name=calls_limit,json=callsLimit,proto3" json:"calls_limit,omitempty"` + // Function callback that allows to control output values. The function + // receives the following arguments: tuple, tuple_key (extracted key from + // the tuple) and func_arg. The callback must return: + // - key - for the next iteration, + // - iterator - for the next iteration, + // - tuple (or nil) - to store in the result set, + // - eof flag (true or false) - to stop all iterations if true. + Func string `protobuf:"bytes,6,opt,name=func,proto3" json:"func,omitempty"` + // Function argument. + FuncArg *Value `protobuf:"bytes,7,opt,name=func_arg,json=funcArg,proto3" json:"func_arg,omitempty"` + // Max number of tuples in each response. + ChunkSize uint64 `protobuf:"varint,8,opt,name=chunk_size,json=chunkSize,proto3" json:"chunk_size,omitempty"` +} + +func (x *SelectRequest) Reset() { + *x = SelectRequest{} + mi := &file_aeon_router_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SelectRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SelectRequest) ProtoMessage() {} + +func (x *SelectRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SelectRequest.ProtoReflect.Descriptor instead. +func (*SelectRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{27} +} + +func (x *SelectRequest) GetSpace() string { + if x != nil { + return x.Space + } + return "" +} + +func (x *SelectRequest) GetKey() *Tuple { + if x != nil { + return x.Key + } + return nil +} + +func (x *SelectRequest) GetIterator() SelectIterator { + if x != nil { + return x.Iterator + } + return SelectIterator_SELECT_ITERATOR_GT +} + +func (x *SelectRequest) GetLimit() uint64 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *SelectRequest) GetCallsLimit() uint64 { + if x != nil { + return x.CallsLimit + } + return 0 +} + +func (x *SelectRequest) GetFunc() string { + if x != nil { + return x.Func + } + return "" +} + +func (x *SelectRequest) GetFuncArg() *Value { + if x != nil { + return x.FuncArg + } + return nil +} + +func (x *SelectRequest) GetChunkSize() uint64 { + if x != nil { + return x.ChunkSize + } + return 0 +} + +type SelectResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Retrieved tuples in the chunk. + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Number of calls in the chunk. + Calls int64 `protobuf:"varint,3,opt,name=calls,proto3" json:"calls,omitempty"` + // Number of roundtrips done to get all returned tuples. + Roundtrips int64 `protobuf:"varint,4,opt,name=roundtrips,proto3" json:"roundtrips,omitempty"` + // Key for the next chunk. + Key *Tuple `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"` + // Iterator for the next chunk. + Iterator SelectIterator `protobuf:"varint,6,opt,name=iterator,proto3,enum=aeon_router.SelectIterator" json:"iterator,omitempty"` + // True if there are no more tuples left, false otherwise. + IsEof bool `protobuf:"varint,7,opt,name=is_eof,json=isEof,proto3" json:"is_eof,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,8,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *SelectResponse) Reset() { + *x = SelectResponse{} + mi := &file_aeon_router_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SelectResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SelectResponse) ProtoMessage() {} + +func (x *SelectResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SelectResponse.ProtoReflect.Descriptor instead. +func (*SelectResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{28} +} + +func (x *SelectResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *SelectResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *SelectResponse) GetCalls() int64 { + if x != nil { + return x.Calls + } + return 0 +} + +func (x *SelectResponse) GetRoundtrips() int64 { + if x != nil { + return x.Roundtrips + } + return 0 +} + +func (x *SelectResponse) GetKey() *Tuple { + if x != nil { + return x.Key + } + return nil +} + +func (x *SelectResponse) GetIterator() SelectIterator { + if x != nil { + return x.Iterator + } + return SelectIterator_SELECT_ITERATOR_GT +} + +func (x *SelectResponse) GetIsEof() bool { + if x != nil { + return x.IsEof + } + return false +} + +func (x *SelectResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type SQLRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // SQL query. + Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + // Bind variables. + Vars map[string]*Value `protobuf:"bytes,2,rep,name=vars,proto3" json:"vars,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *SQLRequest) Reset() { + *x = SQLRequest{} + mi := &file_aeon_router_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SQLRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SQLRequest) ProtoMessage() {} + +func (x *SQLRequest) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SQLRequest.ProtoReflect.Descriptor instead. +func (*SQLRequest) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{29} +} + +func (x *SQLRequest) GetQuery() string { + if x != nil { + return x.Query + } + return "" +} + +func (x *SQLRequest) GetVars() map[string]*Value { + if x != nil { + return x.Vars + } + return nil +} + +type SQLResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Error information. Set only on failure. + Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + // Retrieved tuples. + Tuples []*Tuple `protobuf:"bytes,2,rep,name=tuples,proto3" json:"tuples,omitempty"` + // Format of the returned tuples. + TupleFormat *TupleFormat `protobuf:"bytes,3,opt,name=tuple_format,json=tupleFormat,proto3" json:"tuple_format,omitempty"` +} + +func (x *SQLResponse) Reset() { + *x = SQLResponse{} + mi := &file_aeon_router_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SQLResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SQLResponse) ProtoMessage() {} + +func (x *SQLResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SQLResponse.ProtoReflect.Descriptor instead. +func (*SQLResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{30} +} + +func (x *SQLResponse) GetError() *Error { + if x != nil { + return x.Error + } + return nil +} + +func (x *SQLResponse) GetTuples() []*Tuple { + if x != nil { + return x.Tuples + } + return nil +} + +func (x *SQLResponse) GetTupleFormat() *TupleFormat { + if x != nil { + return x.TupleFormat + } + return nil +} + +type SQLCheckResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status SQLCheckStatus `protobuf:"varint,1,opt,name=status,proto3,enum=aeon_router.SQLCheckStatus" json:"status,omitempty"` +} + +func (x *SQLCheckResponse) Reset() { + *x = SQLCheckResponse{} + mi := &file_aeon_router_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SQLCheckResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SQLCheckResponse) ProtoMessage() {} + +func (x *SQLCheckResponse) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SQLCheckResponse.ProtoReflect.Descriptor instead. +func (*SQLCheckResponse) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{31} +} + +func (x *SQLCheckResponse) GetStatus() SQLCheckStatus { + if x != nil { + return x.Status + } + return SQLCheckStatus_SQL_QUERY_VALID +} + +type InsertRequest_InsertFlags struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If set, return the inserted (new) tuples. + ReturnTuples bool `protobuf:"varint,1,opt,name=return_tuples,json=returnTuples,proto3" json:"return_tuples,omitempty"` +} + +func (x *InsertRequest_InsertFlags) Reset() { + *x = InsertRequest_InsertFlags{} + mi := &file_aeon_router_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InsertRequest_InsertFlags) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InsertRequest_InsertFlags) ProtoMessage() {} + +func (x *InsertRequest_InsertFlags) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[36] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InsertRequest_InsertFlags.ProtoReflect.Descriptor instead. +func (*InsertRequest_InsertFlags) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{19, 0} +} + +func (x *InsertRequest_InsertFlags) GetReturnTuples() bool { + if x != nil { + return x.ReturnTuples + } + return false +} + +type ReplaceRequest_ReplaceFlags struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If set, return the inserted (new) tuples. + ReturnTuples bool `protobuf:"varint,1,opt,name=return_tuples,json=returnTuples,proto3" json:"return_tuples,omitempty"` +} + +func (x *ReplaceRequest_ReplaceFlags) Reset() { + *x = ReplaceRequest_ReplaceFlags{} + mi := &file_aeon_router_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplaceRequest_ReplaceFlags) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplaceRequest_ReplaceFlags) ProtoMessage() {} + +func (x *ReplaceRequest_ReplaceFlags) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[37] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplaceRequest_ReplaceFlags.ProtoReflect.Descriptor instead. +func (*ReplaceRequest_ReplaceFlags) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{21, 0} +} + +func (x *ReplaceRequest_ReplaceFlags) GetReturnTuples() bool { + if x != nil { + return x.ReturnTuples + } + return false +} + +type DeleteRequest_DeleteFlags struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // If set, return the deleted (old) tuples. + ReturnTuples bool `protobuf:"varint,1,opt,name=return_tuples,json=returnTuples,proto3" json:"return_tuples,omitempty"` +} + +func (x *DeleteRequest_DeleteFlags) Reset() { + *x = DeleteRequest_DeleteFlags{} + mi := &file_aeon_router_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteRequest_DeleteFlags) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteRequest_DeleteFlags) ProtoMessage() {} + +func (x *DeleteRequest_DeleteFlags) ProtoReflect() protoreflect.Message { + mi := &file_aeon_router_proto_msgTypes[38] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteRequest_DeleteFlags.ProtoReflect.Descriptor instead. +func (*DeleteRequest_DeleteFlags) Descriptor() ([]byte, []int) { + return file_aeon_router_proto_rawDescGZIP(), []int{23, 0} +} + +func (x *DeleteRequest_DeleteFlags) GetReturnTuples() bool { + if x != nil { + return x.ReturnTuples + } + return false +} + +var File_aeon_router_proto protoreflect.FileDescriptor + +var file_aeon_router_proto_rawDesc = []byte{ + 0x0a, 0x11, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x22, 0x38, 0x0a, 0x0a, 0x41, 0x72, 0x72, 0x61, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2a, + 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0x94, 0x01, 0x0a, 0x08, 0x4d, + 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x39, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x73, 0x1a, 0x4d, 0x0a, 0x0b, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x28, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x59, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x73, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x6e, 0x73, 0x65, 0x63, + 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xd0, 0x02, 0x0a, + 0x0d, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x79, 0x65, + 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x77, 0x65, 0x65, 0x6b, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x77, 0x65, 0x65, 0x6b, 0x12, 0x10, 0x0a, 0x03, + 0x64, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x64, 0x61, 0x79, 0x12, 0x12, + 0x0a, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x68, 0x6f, + 0x75, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x03, 0x6d, 0x69, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x65, 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x73, 0x65, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x73, 0x65, 0x63, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x6e, 0x73, 0x65, 0x63, 0x12, 0x41, 0x0a, 0x06, 0x61, 0x64, + 0x6a, 0x75, 0x73, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, + 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x41, + 0x64, 0x6a, 0x75, 0x73, 0x74, 0x52, 0x06, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x22, 0x60, 0x0a, + 0x0e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x41, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x12, + 0x18, 0x0a, 0x14, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x56, 0x41, 0x4c, 0x5f, 0x41, 0x44, 0x4a, 0x55, + 0x53, 0x54, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x49, 0x4e, 0x54, + 0x45, 0x52, 0x56, 0x41, 0x4c, 0x5f, 0x41, 0x44, 0x4a, 0x55, 0x53, 0x54, 0x5f, 0x45, 0x58, 0x43, + 0x45, 0x53, 0x53, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x56, 0x41, + 0x4c, 0x5f, 0x41, 0x44, 0x4a, 0x55, 0x53, 0x54, 0x5f, 0x4c, 0x41, 0x53, 0x54, 0x10, 0x02, 0x22, + 0xf8, 0x04, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27, 0x0a, 0x0e, 0x75, 0x6e, 0x73, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x48, 0x00, 0x52, 0x0d, 0x75, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, + 0x0b, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, + 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x12, 0x48, 0x00, 0x52, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x65, 0x72, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x62, 0x6f, + 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x29, 0x0a, 0x0f, 0x76, 0x61, + 0x72, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0e, 0x76, 0x61, 0x72, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, + 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0a, + 0x75, 0x75, 0x69, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x09, 0x75, 0x75, 0x69, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x43, 0x0a, + 0x0e, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x43, 0x0a, 0x0e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, + 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, + 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3a, 0x0a, 0x0b, 0x61, 0x72, 0x72, 0x61, 0x79, + 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, + 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x72, 0x61, 0x79, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4d, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, + 0x08, 0x6d, 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x37, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, + 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, + 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4e, 0x75, 0x6c, 0x6c, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x6e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0xea, 0x01, 0x0a, 0x05, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, + 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6e, 0x6f, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6e, 0x6f, 0x12, 0x12, 0x0a, 0x04, + 0x63, 0x6f, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, + 0x12, 0x2d, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x15, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4d, + 0x61, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, + 0x26, 0x0a, 0x04, 0x70, 0x72, 0x65, 0x76, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x52, 0x04, 0x70, 0x72, 0x65, 0x76, 0x22, 0x33, 0x0a, 0x05, 0x54, 0x75, 0x70, 0x6c, 0x65, + 0x12, 0x2a, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x22, 0x23, 0x0a, 0x0b, + 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x22, 0x71, 0x0a, 0x09, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x28, 0x0a, 0x05, 0x74, 0x75, + 0x70, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x05, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x22, 0x6b, 0x0a, 0x08, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x66, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2a, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x6e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x4e, 0x75, 0x6c, 0x6c, 0x61, 0x62, 0x6c, + 0x65, 0x22, 0x81, 0x02, 0x0a, 0x0a, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x44, 0x65, 0x66, + 0x12, 0x10, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x14, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2a, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x72, 0x64, + 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x44, 0x65, + 0x66, 0x2e, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x53, 0x6f, 0x72, 0x74, 0x4f, 0x72, 0x64, + 0x65, 0x72, 0x52, 0x09, 0x73, 0x6f, 0x72, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x22, 0x4d, 0x0a, + 0x10, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x53, 0x6f, 0x72, 0x74, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x12, 0x1b, 0x0a, 0x17, 0x4b, 0x45, 0x59, 0x5f, 0x50, 0x41, 0x52, 0x54, 0x5f, 0x53, 0x4f, + 0x52, 0x54, 0x5f, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x43, 0x10, 0x00, 0x12, 0x1c, + 0x0a, 0x18, 0x4b, 0x45, 0x59, 0x5f, 0x50, 0x41, 0x52, 0x54, 0x5f, 0x53, 0x4f, 0x52, 0x54, 0x5f, + 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x53, 0x43, 0x10, 0x01, 0x42, 0x07, 0x0a, 0x05, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x0d, 0x0a, 0x0b, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0x38, 0x0a, 0x0c, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x89, + 0x01, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x66, + 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x30, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, + 0x64, 0x65, 0x66, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x44, + 0x65, 0x66, 0x52, 0x06, 0x6b, 0x65, 0x79, 0x44, 0x65, 0x66, 0x22, 0x3f, 0x0a, 0x13, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x26, 0x0a, 0x10, 0x44, + 0x72, 0x6f, 0x70, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x22, 0x3d, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x53, 0x70, 0x61, 0x63, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x22, 0x91, 0x04, 0x0a, 0x0e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x08, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x73, 0x65, + 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x07, 0x72, 0x65, 0x61, 0x64, 0x53, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x09, 0x77, 0x72, 0x69, 0x74, + 0x65, 0x5f, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x65, + 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x77, 0x72, 0x69, 0x74, 0x65, 0x53, 0x65, 0x74, 0x12, 0x12, 0x0a, + 0x04, 0x66, 0x75, 0x6e, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x75, 0x6e, + 0x63, 0x12, 0x2d, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x5f, 0x61, 0x72, 0x67, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x66, 0x75, 0x6e, 0x63, 0x41, 0x72, 0x67, + 0x12, 0x4c, 0x0a, 0x0b, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x4b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0a, 0x6b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x12, 0x52, + 0x0a, 0x0d, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x18, + 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x73, 0x1a, 0x57, 0x0a, 0x0f, 0x4b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x59, 0x0a, 0x11, 0x54, + 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x82, 0x03, 0x0a, 0x0f, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, + 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x12, 0x31, 0x0a, 0x08, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x73, 0x65, 0x74, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, + 0x72, 0x65, 0x61, 0x64, 0x53, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x09, 0x77, 0x72, 0x69, 0x74, 0x65, + 0x5f, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x08, 0x77, 0x72, 0x69, 0x74, 0x65, 0x53, 0x65, 0x74, 0x12, 0x2d, 0x0a, 0x08, + 0x66, 0x75, 0x6e, 0x63, 0x5f, 0x72, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x07, 0x66, 0x75, 0x6e, 0x63, 0x52, 0x65, 0x74, 0x12, 0x53, 0x0a, 0x0d, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, + 0x1a, 0x59, 0x0a, 0x11, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x80, 0x02, 0x0a, 0x0d, + 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, + 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, + 0x3c, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x73, + 0x65, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x49, 0x6e, 0x73, 0x65, 0x72, + 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x3b, 0x0a, + 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x1a, 0x32, 0x0a, 0x0b, 0x49, 0x6e, + 0x73, 0x65, 0x72, 0x74, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, + 0x75, 0x72, 0x6e, 0x5f, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x22, 0xa3, + 0x01, 0x0a, 0x0e, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, + 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, + 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, + 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, + 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x22, 0x84, 0x02, 0x0a, 0x0e, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x2a, 0x0a, + 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, + 0x65, 0x52, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x05, 0x66, 0x6c, 0x61, + 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x46, 0x6c, 0x61, + 0x67, 0x73, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, + 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, + 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, + 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x1a, 0x33, 0x0a, 0x0c, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, + 0x65, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x5f, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, + 0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x22, 0xa4, 0x01, 0x0a, 0x0f, + 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, 0x70, + 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, + 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x22, 0xf8, 0x01, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6b, 0x65, + 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x04, 0x6b, 0x65, + 0x79, 0x73, 0x12, 0x3c, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x26, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, + 0x12, 0x37, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, + 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x09, + 0x6b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x1a, 0x32, 0x0a, 0x0b, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x75, + 0x72, 0x6e, 0x5f, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x22, 0xa3, 0x01, + 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, + 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, + 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, + 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, + 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x22, 0x83, 0x01, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, + 0x12, 0x37, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, + 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x09, + 0x6b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0xa0, 0x01, 0x0a, 0x0b, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, + 0x72, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, + 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, + 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0x9d, 0x02, 0x0a, + 0x0d, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x37, 0x0a, 0x08, 0x69, 0x74, + 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x61, + 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x69, 0x74, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x61, 0x6c, + 0x6c, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, + 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x75, + 0x6e, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x75, 0x6e, 0x63, 0x12, 0x2d, + 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x5f, 0x61, 0x72, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x66, 0x75, 0x6e, 0x63, 0x41, 0x72, 0x67, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x09, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x53, 0x69, 0x7a, 0x65, 0x22, 0xcf, 0x02, 0x0a, + 0x0e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, 0x70, + 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x72, + 0x6f, 0x75, 0x6e, 0x64, 0x74, 0x72, 0x69, 0x70, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x74, 0x72, 0x69, 0x70, 0x73, 0x12, 0x24, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x37, 0x0a, 0x08, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x52, 0x08, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x15, 0x0a, 0x06, 0x69, 0x73, + 0x5f, 0x65, 0x6f, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x69, 0x73, 0x45, 0x6f, + 0x66, 0x12, 0x3b, 0x0a, 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x52, 0x0b, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0xa6, + 0x01, 0x0a, 0x0a, 0x53, 0x51, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, + 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x12, 0x35, 0x0a, 0x04, 0x76, 0x61, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x53, 0x51, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x56, 0x61, 0x72, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x76, 0x61, 0x72, 0x73, 0x1a, 0x4b, 0x0a, 0x09, 0x56, 0x61, + 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x28, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa0, 0x01, 0x0a, 0x0b, 0x53, 0x51, 0x4c, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x12, 0x2a, 0x0a, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x54, 0x75, 0x70, 0x6c, 0x65, 0x52, 0x06, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x73, 0x12, 0x3b, 0x0a, + 0x0c, 0x74, 0x75, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x54, 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x0b, 0x74, + 0x75, 0x70, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0x47, 0x0a, 0x10, 0x53, 0x51, + 0x4c, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, + 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, + 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x2a, 0x1b, 0x0a, 0x09, 0x4e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x55, 0x4c, 0x4c, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x10, 0x00, + 0x2a, 0x83, 0x03, 0x0a, 0x09, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, + 0x0a, 0x16, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x46, 0x49, + 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x4e, 0x59, 0x10, 0x01, 0x12, 0x17, + 0x0a, 0x13, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, + 0x49, 0x47, 0x4e, 0x45, 0x44, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x45, 0x4c, 0x44, + 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x15, + 0x0a, 0x11, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x55, 0x4d, + 0x42, 0x45, 0x52, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, + 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x47, + 0x45, 0x52, 0x10, 0x06, 0x12, 0x16, 0x0a, 0x12, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x10, 0x07, 0x12, 0x18, 0x0a, 0x14, + 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x56, 0x41, 0x52, 0x42, 0x49, + 0x4e, 0x41, 0x52, 0x59, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x43, 0x41, 0x4c, 0x41, 0x52, 0x10, 0x09, 0x12, 0x16, 0x0a, + 0x12, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x49, + 0x4d, 0x41, 0x4c, 0x10, 0x0a, 0x12, 0x13, 0x0a, 0x0f, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x55, 0x49, 0x44, 0x10, 0x0b, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, + 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x41, 0x54, 0x45, 0x54, 0x49, 0x4d, + 0x45, 0x10, 0x0c, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x56, 0x41, 0x4c, 0x10, 0x0d, 0x12, 0x14, 0x0a, 0x10, + 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x52, 0x52, 0x41, 0x59, + 0x10, 0x0e, 0x12, 0x12, 0x0a, 0x0e, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x4d, 0x41, 0x50, 0x10, 0x0f, 0x2a, 0xa0, 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x6c, 0x65, 0x63, + 0x74, 0x49, 0x74, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, + 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x47, 0x54, 0x10, + 0x00, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, + 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x47, 0x45, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, + 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4c, 0x54, 0x10, + 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, + 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4c, 0x45, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, + 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x50, 0x50, 0x10, + 0x04, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x49, 0x54, 0x45, 0x52, + 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4e, 0x50, 0x10, 0x05, 0x2a, 0x56, 0x0a, 0x0e, 0x53, 0x51, 0x4c, + 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x13, 0x0a, 0x0f, 0x53, + 0x51, 0x4c, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x59, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x10, 0x00, + 0x12, 0x18, 0x0a, 0x14, 0x53, 0x51, 0x4c, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x59, 0x5f, 0x49, 0x4e, + 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x51, + 0x4c, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x59, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x10, + 0x02, 0x32, 0xd7, 0x06, 0x0a, 0x11, 0x41, 0x65, 0x6f, 0x6e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, + 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x50, 0x69, + 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x53, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1f, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4c, 0x0a, 0x09, 0x44, 0x72, + 0x6f, 0x70, 0x53, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x53, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a, 0x07, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x65, 0x12, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1c, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x43, 0x0a, 0x06, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x12, 0x1a, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x46, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x12, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x52, + 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, + 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x70, 0x6c, + 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x43, 0x0a, + 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1a, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x3a, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x17, 0x2e, 0x61, 0x65, 0x6f, 0x6e, + 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, + 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x45, + 0x0a, 0x06, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x12, 0x1a, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, + 0x65, 0x72, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x3a, 0x0a, 0x03, 0x53, 0x51, 0x4c, 0x12, 0x17, 0x2e, 0x61, + 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x42, 0x0a, 0x09, 0x53, 0x51, 0x4c, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x17, + 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x44, 0x0a, 0x08, 0x53, 0x51, 0x4c, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x12, 0x17, 0x2e, 0x61, 0x65, 0x6f, 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, + 0x53, 0x51, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x61, 0x65, 0x6f, + 0x6e, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x53, 0x51, 0x4c, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x06, 0x5a, 0x04, 0x2e, + 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_aeon_router_proto_rawDescOnce sync.Once + file_aeon_router_proto_rawDescData = file_aeon_router_proto_rawDesc +) + +func file_aeon_router_proto_rawDescGZIP() []byte { + file_aeon_router_proto_rawDescOnce.Do(func() { + file_aeon_router_proto_rawDescData = protoimpl.X.CompressGZIP(file_aeon_router_proto_rawDescData) + }) + return file_aeon_router_proto_rawDescData +} + +var file_aeon_router_proto_enumTypes = make([]protoimpl.EnumInfo, 6) +var file_aeon_router_proto_msgTypes = make([]protoimpl.MessageInfo, 40) +var file_aeon_router_proto_goTypes = []any{ + (NullValue)(0), // 0: aeon_router.NullValue + (FieldType)(0), // 1: aeon_router.FieldType + (SelectIterator)(0), // 2: aeon_router.SelectIterator + (SQLCheckStatus)(0), // 3: aeon_router.SQLCheckStatus + (IntervalValue_IntervalAdjust)(0), // 4: aeon_router.IntervalValue.IntervalAdjust + (KeyPartDef_KeyPartSortOrder)(0), // 5: aeon_router.KeyPartDef.KeyPartSortOrder + (*ArrayValue)(nil), // 6: aeon_router.ArrayValue + (*MapValue)(nil), // 7: aeon_router.MapValue + (*DateTimeValue)(nil), // 8: aeon_router.DateTimeValue + (*IntervalValue)(nil), // 9: aeon_router.IntervalValue + (*Value)(nil), // 10: aeon_router.Value + (*Error)(nil), // 11: aeon_router.Error + (*Tuple)(nil), // 12: aeon_router.Tuple + (*TupleFormat)(nil), // 13: aeon_router.TupleFormat + (*Operation)(nil), // 14: aeon_router.Operation + (*FieldDef)(nil), // 15: aeon_router.FieldDef + (*KeyPartDef)(nil), // 16: aeon_router.KeyPartDef + (*PingRequest)(nil), // 17: aeon_router.PingRequest + (*PingResponse)(nil), // 18: aeon_router.PingResponse + (*CreateSpaceRequest)(nil), // 19: aeon_router.CreateSpaceRequest + (*CreateSpaceResponse)(nil), // 20: aeon_router.CreateSpaceResponse + (*DropSpaceRequest)(nil), // 21: aeon_router.DropSpaceRequest + (*DropSpaceResponse)(nil), // 22: aeon_router.DropSpaceResponse + (*ExecuteRequest)(nil), // 23: aeon_router.ExecuteRequest + (*ExecuteResponse)(nil), // 24: aeon_router.ExecuteResponse + (*InsertRequest)(nil), // 25: aeon_router.InsertRequest + (*InsertResponse)(nil), // 26: aeon_router.InsertResponse + (*ReplaceRequest)(nil), // 27: aeon_router.ReplaceRequest + (*ReplaceResponse)(nil), // 28: aeon_router.ReplaceResponse + (*DeleteRequest)(nil), // 29: aeon_router.DeleteRequest + (*DeleteResponse)(nil), // 30: aeon_router.DeleteResponse + (*GetRequest)(nil), // 31: aeon_router.GetRequest + (*GetResponse)(nil), // 32: aeon_router.GetResponse + (*SelectRequest)(nil), // 33: aeon_router.SelectRequest + (*SelectResponse)(nil), // 34: aeon_router.SelectResponse + (*SQLRequest)(nil), // 35: aeon_router.SQLRequest + (*SQLResponse)(nil), // 36: aeon_router.SQLResponse + (*SQLCheckResponse)(nil), // 37: aeon_router.SQLCheckResponse + nil, // 38: aeon_router.MapValue.FieldsEntry + nil, // 39: aeon_router.ExecuteRequest.KeyFormatsEntry + nil, // 40: aeon_router.ExecuteRequest.TupleFormatsEntry + nil, // 41: aeon_router.ExecuteResponse.TupleFormatsEntry + (*InsertRequest_InsertFlags)(nil), // 42: aeon_router.InsertRequest.InsertFlags + (*ReplaceRequest_ReplaceFlags)(nil), // 43: aeon_router.ReplaceRequest.ReplaceFlags + (*DeleteRequest_DeleteFlags)(nil), // 44: aeon_router.DeleteRequest.DeleteFlags + nil, // 45: aeon_router.SQLRequest.VarsEntry +} +var file_aeon_router_proto_depIdxs = []int32{ + 10, // 0: aeon_router.ArrayValue.fields:type_name -> aeon_router.Value + 38, // 1: aeon_router.MapValue.fields:type_name -> aeon_router.MapValue.FieldsEntry + 4, // 2: aeon_router.IntervalValue.adjust:type_name -> aeon_router.IntervalValue.IntervalAdjust + 8, // 3: aeon_router.Value.datetime_value:type_name -> aeon_router.DateTimeValue + 9, // 4: aeon_router.Value.interval_value:type_name -> aeon_router.IntervalValue + 6, // 5: aeon_router.Value.array_value:type_name -> aeon_router.ArrayValue + 7, // 6: aeon_router.Value.map_value:type_name -> aeon_router.MapValue + 0, // 7: aeon_router.Value.null_value:type_name -> aeon_router.NullValue + 7, // 8: aeon_router.Error.fields:type_name -> aeon_router.MapValue + 11, // 9: aeon_router.Error.prev:type_name -> aeon_router.Error + 10, // 10: aeon_router.Tuple.fields:type_name -> aeon_router.Value + 12, // 11: aeon_router.Operation.key:type_name -> aeon_router.Tuple + 12, // 12: aeon_router.Operation.tuple:type_name -> aeon_router.Tuple + 1, // 13: aeon_router.FieldDef.type:type_name -> aeon_router.FieldType + 1, // 14: aeon_router.KeyPartDef.type:type_name -> aeon_router.FieldType + 5, // 15: aeon_router.KeyPartDef.sort_order:type_name -> aeon_router.KeyPartDef.KeyPartSortOrder + 11, // 16: aeon_router.PingResponse.error:type_name -> aeon_router.Error + 15, // 17: aeon_router.CreateSpaceRequest.format:type_name -> aeon_router.FieldDef + 16, // 18: aeon_router.CreateSpaceRequest.key_def:type_name -> aeon_router.KeyPartDef + 11, // 19: aeon_router.CreateSpaceResponse.error:type_name -> aeon_router.Error + 11, // 20: aeon_router.DropSpaceResponse.error:type_name -> aeon_router.Error + 14, // 21: aeon_router.ExecuteRequest.read_set:type_name -> aeon_router.Operation + 14, // 22: aeon_router.ExecuteRequest.write_set:type_name -> aeon_router.Operation + 10, // 23: aeon_router.ExecuteRequest.func_arg:type_name -> aeon_router.Value + 39, // 24: aeon_router.ExecuteRequest.key_formats:type_name -> aeon_router.ExecuteRequest.KeyFormatsEntry + 40, // 25: aeon_router.ExecuteRequest.tuple_formats:type_name -> aeon_router.ExecuteRequest.TupleFormatsEntry + 11, // 26: aeon_router.ExecuteResponse.error:type_name -> aeon_router.Error + 14, // 27: aeon_router.ExecuteResponse.read_set:type_name -> aeon_router.Operation + 14, // 28: aeon_router.ExecuteResponse.write_set:type_name -> aeon_router.Operation + 10, // 29: aeon_router.ExecuteResponse.func_ret:type_name -> aeon_router.Value + 41, // 30: aeon_router.ExecuteResponse.tuple_formats:type_name -> aeon_router.ExecuteResponse.TupleFormatsEntry + 12, // 31: aeon_router.InsertRequest.tuples:type_name -> aeon_router.Tuple + 42, // 32: aeon_router.InsertRequest.flags:type_name -> aeon_router.InsertRequest.InsertFlags + 13, // 33: aeon_router.InsertRequest.tuple_format:type_name -> aeon_router.TupleFormat + 11, // 34: aeon_router.InsertResponse.error:type_name -> aeon_router.Error + 12, // 35: aeon_router.InsertResponse.tuples:type_name -> aeon_router.Tuple + 13, // 36: aeon_router.InsertResponse.tuple_format:type_name -> aeon_router.TupleFormat + 12, // 37: aeon_router.ReplaceRequest.tuples:type_name -> aeon_router.Tuple + 43, // 38: aeon_router.ReplaceRequest.flags:type_name -> aeon_router.ReplaceRequest.ReplaceFlags + 13, // 39: aeon_router.ReplaceRequest.tuple_format:type_name -> aeon_router.TupleFormat + 11, // 40: aeon_router.ReplaceResponse.error:type_name -> aeon_router.Error + 12, // 41: aeon_router.ReplaceResponse.tuples:type_name -> aeon_router.Tuple + 13, // 42: aeon_router.ReplaceResponse.tuple_format:type_name -> aeon_router.TupleFormat + 12, // 43: aeon_router.DeleteRequest.keys:type_name -> aeon_router.Tuple + 44, // 44: aeon_router.DeleteRequest.flags:type_name -> aeon_router.DeleteRequest.DeleteFlags + 13, // 45: aeon_router.DeleteRequest.key_format:type_name -> aeon_router.TupleFormat + 11, // 46: aeon_router.DeleteResponse.error:type_name -> aeon_router.Error + 12, // 47: aeon_router.DeleteResponse.tuples:type_name -> aeon_router.Tuple + 13, // 48: aeon_router.DeleteResponse.tuple_format:type_name -> aeon_router.TupleFormat + 12, // 49: aeon_router.GetRequest.keys:type_name -> aeon_router.Tuple + 13, // 50: aeon_router.GetRequest.key_format:type_name -> aeon_router.TupleFormat + 11, // 51: aeon_router.GetResponse.error:type_name -> aeon_router.Error + 12, // 52: aeon_router.GetResponse.tuples:type_name -> aeon_router.Tuple + 13, // 53: aeon_router.GetResponse.tuple_format:type_name -> aeon_router.TupleFormat + 12, // 54: aeon_router.SelectRequest.key:type_name -> aeon_router.Tuple + 2, // 55: aeon_router.SelectRequest.iterator:type_name -> aeon_router.SelectIterator + 10, // 56: aeon_router.SelectRequest.func_arg:type_name -> aeon_router.Value + 11, // 57: aeon_router.SelectResponse.error:type_name -> aeon_router.Error + 12, // 58: aeon_router.SelectResponse.tuples:type_name -> aeon_router.Tuple + 12, // 59: aeon_router.SelectResponse.key:type_name -> aeon_router.Tuple + 2, // 60: aeon_router.SelectResponse.iterator:type_name -> aeon_router.SelectIterator + 13, // 61: aeon_router.SelectResponse.tuple_format:type_name -> aeon_router.TupleFormat + 45, // 62: aeon_router.SQLRequest.vars:type_name -> aeon_router.SQLRequest.VarsEntry + 11, // 63: aeon_router.SQLResponse.error:type_name -> aeon_router.Error + 12, // 64: aeon_router.SQLResponse.tuples:type_name -> aeon_router.Tuple + 13, // 65: aeon_router.SQLResponse.tuple_format:type_name -> aeon_router.TupleFormat + 3, // 66: aeon_router.SQLCheckResponse.status:type_name -> aeon_router.SQLCheckStatus + 10, // 67: aeon_router.MapValue.FieldsEntry.value:type_name -> aeon_router.Value + 13, // 68: aeon_router.ExecuteRequest.KeyFormatsEntry.value:type_name -> aeon_router.TupleFormat + 13, // 69: aeon_router.ExecuteRequest.TupleFormatsEntry.value:type_name -> aeon_router.TupleFormat + 13, // 70: aeon_router.ExecuteResponse.TupleFormatsEntry.value:type_name -> aeon_router.TupleFormat + 10, // 71: aeon_router.SQLRequest.VarsEntry.value:type_name -> aeon_router.Value + 17, // 72: aeon_router.AeonRouterService.Ping:input_type -> aeon_router.PingRequest + 19, // 73: aeon_router.AeonRouterService.CreateSpace:input_type -> aeon_router.CreateSpaceRequest + 21, // 74: aeon_router.AeonRouterService.DropSpace:input_type -> aeon_router.DropSpaceRequest + 23, // 75: aeon_router.AeonRouterService.Execute:input_type -> aeon_router.ExecuteRequest + 25, // 76: aeon_router.AeonRouterService.Insert:input_type -> aeon_router.InsertRequest + 27, // 77: aeon_router.AeonRouterService.Replace:input_type -> aeon_router.ReplaceRequest + 29, // 78: aeon_router.AeonRouterService.Delete:input_type -> aeon_router.DeleteRequest + 31, // 79: aeon_router.AeonRouterService.Get:input_type -> aeon_router.GetRequest + 33, // 80: aeon_router.AeonRouterService.Select:input_type -> aeon_router.SelectRequest + 35, // 81: aeon_router.AeonRouterService.SQL:input_type -> aeon_router.SQLRequest + 35, // 82: aeon_router.AeonRouterService.SQLStream:input_type -> aeon_router.SQLRequest + 35, // 83: aeon_router.AeonRouterService.SQLCheck:input_type -> aeon_router.SQLRequest + 18, // 84: aeon_router.AeonRouterService.Ping:output_type -> aeon_router.PingResponse + 20, // 85: aeon_router.AeonRouterService.CreateSpace:output_type -> aeon_router.CreateSpaceResponse + 22, // 86: aeon_router.AeonRouterService.DropSpace:output_type -> aeon_router.DropSpaceResponse + 24, // 87: aeon_router.AeonRouterService.Execute:output_type -> aeon_router.ExecuteResponse + 26, // 88: aeon_router.AeonRouterService.Insert:output_type -> aeon_router.InsertResponse + 28, // 89: aeon_router.AeonRouterService.Replace:output_type -> aeon_router.ReplaceResponse + 30, // 90: aeon_router.AeonRouterService.Delete:output_type -> aeon_router.DeleteResponse + 32, // 91: aeon_router.AeonRouterService.Get:output_type -> aeon_router.GetResponse + 34, // 92: aeon_router.AeonRouterService.Select:output_type -> aeon_router.SelectResponse + 36, // 93: aeon_router.AeonRouterService.SQL:output_type -> aeon_router.SQLResponse + 36, // 94: aeon_router.AeonRouterService.SQLStream:output_type -> aeon_router.SQLResponse + 37, // 95: aeon_router.AeonRouterService.SQLCheck:output_type -> aeon_router.SQLCheckResponse + 84, // [84:96] is the sub-list for method output_type + 72, // [72:84] is the sub-list for method input_type + 72, // [72:72] is the sub-list for extension type_name + 72, // [72:72] is the sub-list for extension extendee + 0, // [0:72] is the sub-list for field type_name +} + +func init() { file_aeon_router_proto_init() } +func file_aeon_router_proto_init() { + if File_aeon_router_proto != nil { + return + } + file_aeon_router_proto_msgTypes[4].OneofWrappers = []any{ + (*Value_UnsignedValue)(nil), + (*Value_StringValue)(nil), + (*Value_NumberValue)(nil), + (*Value_IntegerValue)(nil), + (*Value_BooleanValue)(nil), + (*Value_VarbinaryValue)(nil), + (*Value_DecimalValue)(nil), + (*Value_UuidValue)(nil), + (*Value_DatetimeValue)(nil), + (*Value_IntervalValue)(nil), + (*Value_ArrayValue)(nil), + (*Value_MapValue)(nil), + (*Value_NullValue)(nil), + } + file_aeon_router_proto_msgTypes[10].OneofWrappers = []any{ + (*KeyPartDef_Id)(nil), + (*KeyPartDef_Name)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_aeon_router_proto_rawDesc, + NumEnums: 6, + NumMessages: 40, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_aeon_router_proto_goTypes, + DependencyIndexes: file_aeon_router_proto_depIdxs, + EnumInfos: file_aeon_router_proto_enumTypes, + MessageInfos: file_aeon_router_proto_msgTypes, + }.Build() + File_aeon_router_proto = out.File + file_aeon_router_proto_rawDesc = nil + file_aeon_router_proto_goTypes = nil + file_aeon_router_proto_depIdxs = nil +} diff --git a/test/integration/aeon/server/pb/aeon_router_grpc.pb.go b/test/integration/aeon/server/pb/aeon_router_grpc.pb.go new file mode 100644 index 000000000..4312f9c4e --- /dev/null +++ b/test/integration/aeon/server/pb/aeon_router_grpc.pb.go @@ -0,0 +1,582 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.28.3 +// source: aeon_router.proto + +package pb + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + AeonRouterService_Ping_FullMethodName = "/aeon_router.AeonRouterService/Ping" + AeonRouterService_CreateSpace_FullMethodName = "/aeon_router.AeonRouterService/CreateSpace" + AeonRouterService_DropSpace_FullMethodName = "/aeon_router.AeonRouterService/DropSpace" + AeonRouterService_Execute_FullMethodName = "/aeon_router.AeonRouterService/Execute" + AeonRouterService_Insert_FullMethodName = "/aeon_router.AeonRouterService/Insert" + AeonRouterService_Replace_FullMethodName = "/aeon_router.AeonRouterService/Replace" + AeonRouterService_Delete_FullMethodName = "/aeon_router.AeonRouterService/Delete" + AeonRouterService_Get_FullMethodName = "/aeon_router.AeonRouterService/Get" + AeonRouterService_Select_FullMethodName = "/aeon_router.AeonRouterService/Select" + AeonRouterService_SQL_FullMethodName = "/aeon_router.AeonRouterService/SQL" + AeonRouterService_SQLStream_FullMethodName = "/aeon_router.AeonRouterService/SQLStream" + AeonRouterService_SQLCheck_FullMethodName = "/aeon_router.AeonRouterService/SQLCheck" +) + +// AeonRouterServiceClient is the client API for AeonRouterService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// API to Aeon - a distributed database based on Tarantool. +type AeonRouterServiceClient interface { + // Pings the router. + Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) + // Creates a space with the given definition. + CreateSpace(ctx context.Context, in *CreateSpaceRequest, opts ...grpc.CallOption) (*CreateSpaceResponse, error) + // Drops a space by name. + DropSpace(ctx context.Context, in *DropSpaceRequest, opts ...grpc.CallOption) (*DropSpaceResponse, error) + // Transactionally executes a set of read and write operations. + Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (*ExecuteResponse, error) + // Transactionally inserts tuples into a space. + // Raises an error if a tuple with the same key already exists. + Insert(ctx context.Context, in *InsertRequest, opts ...grpc.CallOption) (*InsertResponse, error) + // Transactionally replaces tuples in a space. + // If a tuple with the same key already exists, it will be replaced. + Replace(ctx context.Context, in *ReplaceRequest, opts ...grpc.CallOption) (*ReplaceResponse, error) + // Transactionally deletes tuples from a space. + // If a key doesn't exist, it will be ignored (no error is raised). + Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) + // Transactionally queries tuples from a space. + Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) + // Non-transactionally select tuples from a space. + Select(ctx context.Context, in *SelectRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SelectResponse], error) + // Execute a SQL query. + SQL(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (*SQLResponse, error) + // Execute a SQL query and return the result using a stream. + SQLStream(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SQLResponse], error) + // Check if an SQL is valid + // We provide the method for database CLI. + SQLCheck(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (*SQLCheckResponse, error) +} + +type aeonRouterServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAeonRouterServiceClient(cc grpc.ClientConnInterface) AeonRouterServiceClient { + return &aeonRouterServiceClient{cc} +} + +func (c *aeonRouterServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(PingResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Ping_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) CreateSpace(ctx context.Context, in *CreateSpaceRequest, opts ...grpc.CallOption) (*CreateSpaceResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CreateSpaceResponse) + err := c.cc.Invoke(ctx, AeonRouterService_CreateSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) DropSpace(ctx context.Context, in *DropSpaceRequest, opts ...grpc.CallOption) (*DropSpaceResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DropSpaceResponse) + err := c.cc.Invoke(ctx, AeonRouterService_DropSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (*ExecuteResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ExecuteResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Execute_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Insert(ctx context.Context, in *InsertRequest, opts ...grpc.CallOption) (*InsertResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(InsertResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Insert_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Replace(ctx context.Context, in *ReplaceRequest, opts ...grpc.CallOption) (*ReplaceResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ReplaceResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Replace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DeleteResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Delete_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetResponse) + err := c.cc.Invoke(ctx, AeonRouterService_Get_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) Select(ctx context.Context, in *SelectRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SelectResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &AeonRouterService_ServiceDesc.Streams[0], AeonRouterService_Select_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SelectRequest, SelectResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type AeonRouterService_SelectClient = grpc.ServerStreamingClient[SelectResponse] + +func (c *aeonRouterServiceClient) SQL(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (*SQLResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SQLResponse) + err := c.cc.Invoke(ctx, AeonRouterService_SQL_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *aeonRouterServiceClient) SQLStream(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SQLResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &AeonRouterService_ServiceDesc.Streams[1], AeonRouterService_SQLStream_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SQLRequest, SQLResponse]{ClientStream: 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 +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type AeonRouterService_SQLStreamClient = grpc.ServerStreamingClient[SQLResponse] + +func (c *aeonRouterServiceClient) SQLCheck(ctx context.Context, in *SQLRequest, opts ...grpc.CallOption) (*SQLCheckResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SQLCheckResponse) + err := c.cc.Invoke(ctx, AeonRouterService_SQLCheck_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AeonRouterServiceServer is the server API for AeonRouterService service. +// All implementations must embed UnimplementedAeonRouterServiceServer +// for forward compatibility. +// +// API to Aeon - a distributed database based on Tarantool. +type AeonRouterServiceServer interface { + // Pings the router. + Ping(context.Context, *PingRequest) (*PingResponse, error) + // Creates a space with the given definition. + CreateSpace(context.Context, *CreateSpaceRequest) (*CreateSpaceResponse, error) + // Drops a space by name. + DropSpace(context.Context, *DropSpaceRequest) (*DropSpaceResponse, error) + // Transactionally executes a set of read and write operations. + Execute(context.Context, *ExecuteRequest) (*ExecuteResponse, error) + // Transactionally inserts tuples into a space. + // Raises an error if a tuple with the same key already exists. + Insert(context.Context, *InsertRequest) (*InsertResponse, error) + // Transactionally replaces tuples in a space. + // If a tuple with the same key already exists, it will be replaced. + Replace(context.Context, *ReplaceRequest) (*ReplaceResponse, error) + // Transactionally deletes tuples from a space. + // If a key doesn't exist, it will be ignored (no error is raised). + Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) + // Transactionally queries tuples from a space. + Get(context.Context, *GetRequest) (*GetResponse, error) + // Non-transactionally select tuples from a space. + Select(*SelectRequest, grpc.ServerStreamingServer[SelectResponse]) error + // Execute a SQL query. + SQL(context.Context, *SQLRequest) (*SQLResponse, error) + // Execute a SQL query and return the result using a stream. + SQLStream(*SQLRequest, grpc.ServerStreamingServer[SQLResponse]) error + // Check if an SQL is valid + // We provide the method for database CLI. + SQLCheck(context.Context, *SQLRequest) (*SQLCheckResponse, error) + mustEmbedUnimplementedAeonRouterServiceServer() +} + +// UnimplementedAeonRouterServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedAeonRouterServiceServer struct{} + +func (UnimplementedAeonRouterServiceServer) Ping(context.Context, *PingRequest) (*PingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented") +} +func (UnimplementedAeonRouterServiceServer) CreateSpace(context.Context, *CreateSpaceRequest) (*CreateSpaceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateSpace not implemented") +} +func (UnimplementedAeonRouterServiceServer) DropSpace(context.Context, *DropSpaceRequest) (*DropSpaceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DropSpace not implemented") +} +func (UnimplementedAeonRouterServiceServer) Execute(context.Context, *ExecuteRequest) (*ExecuteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Execute not implemented") +} +func (UnimplementedAeonRouterServiceServer) Insert(context.Context, *InsertRequest) (*InsertResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Insert not implemented") +} +func (UnimplementedAeonRouterServiceServer) Replace(context.Context, *ReplaceRequest) (*ReplaceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Replace not implemented") +} +func (UnimplementedAeonRouterServiceServer) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented") +} +func (UnimplementedAeonRouterServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedAeonRouterServiceServer) Select(*SelectRequest, grpc.ServerStreamingServer[SelectResponse]) error { + return status.Errorf(codes.Unimplemented, "method Select not implemented") +} +func (UnimplementedAeonRouterServiceServer) SQL(context.Context, *SQLRequest) (*SQLResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SQL not implemented") +} +func (UnimplementedAeonRouterServiceServer) SQLStream(*SQLRequest, grpc.ServerStreamingServer[SQLResponse]) error { + return status.Errorf(codes.Unimplemented, "method SQLStream not implemented") +} +func (UnimplementedAeonRouterServiceServer) SQLCheck(context.Context, *SQLRequest) (*SQLCheckResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SQLCheck not implemented") +} +func (UnimplementedAeonRouterServiceServer) mustEmbedUnimplementedAeonRouterServiceServer() {} +func (UnimplementedAeonRouterServiceServer) testEmbeddedByValue() {} + +// UnsafeAeonRouterServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AeonRouterServiceServer will +// result in compilation errors. +type UnsafeAeonRouterServiceServer interface { + mustEmbedUnimplementedAeonRouterServiceServer() +} + +func RegisterAeonRouterServiceServer(s grpc.ServiceRegistrar, srv AeonRouterServiceServer) { + // If the following call pancis, it indicates UnimplementedAeonRouterServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&AeonRouterService_ServiceDesc, srv) +} + +func _AeonRouterService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).Ping(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Ping_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Ping(ctx, req.(*PingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_CreateSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).CreateSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_CreateSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).CreateSpace(ctx, req.(*CreateSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_DropSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DropSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).DropSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_DropSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).DropSpace(ctx, req.(*DropSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_Execute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExecuteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).Execute(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Execute_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Execute(ctx, req.(*ExecuteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_Insert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InsertRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).Insert(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Insert_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Insert(ctx, req.(*InsertRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_Replace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReplaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).Replace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Replace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Replace(ctx, req.(*ReplaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_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.(AeonRouterServiceServer).Delete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Delete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Delete(ctx, req.(*DeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_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.(AeonRouterServiceServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).Get(ctx, req.(*GetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_Select_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SelectRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AeonRouterServiceServer).Select(m, &grpc.GenericServerStream[SelectRequest, SelectResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type AeonRouterService_SelectServer = grpc.ServerStreamingServer[SelectResponse] + +func _AeonRouterService_SQL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SQLRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).SQL(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_SQL_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).SQL(ctx, req.(*SQLRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AeonRouterService_SQLStream_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SQLRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(AeonRouterServiceServer).SQLStream(m, &grpc.GenericServerStream[SQLRequest, SQLResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type AeonRouterService_SQLStreamServer = grpc.ServerStreamingServer[SQLResponse] + +func _AeonRouterService_SQLCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SQLRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AeonRouterServiceServer).SQLCheck(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AeonRouterService_SQLCheck_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AeonRouterServiceServer).SQLCheck(ctx, req.(*SQLRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// AeonRouterService_ServiceDesc is the grpc.ServiceDesc for AeonRouterService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AeonRouterService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "aeon_router.AeonRouterService", + HandlerType: (*AeonRouterServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Ping", + Handler: _AeonRouterService_Ping_Handler, + }, + { + MethodName: "CreateSpace", + Handler: _AeonRouterService_CreateSpace_Handler, + }, + { + MethodName: "DropSpace", + Handler: _AeonRouterService_DropSpace_Handler, + }, + { + MethodName: "Execute", + Handler: _AeonRouterService_Execute_Handler, + }, + { + MethodName: "Insert", + Handler: _AeonRouterService_Insert_Handler, + }, + { + MethodName: "Replace", + Handler: _AeonRouterService_Replace_Handler, + }, + { + MethodName: "Delete", + Handler: _AeonRouterService_Delete_Handler, + }, + { + MethodName: "Get", + Handler: _AeonRouterService_Get_Handler, + }, + { + MethodName: "SQL", + Handler: _AeonRouterService_SQL_Handler, + }, + { + MethodName: "SQLCheck", + Handler: _AeonRouterService_SQLCheck_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Select", + Handler: _AeonRouterService_Select_Handler, + ServerStreams: true, + }, + { + StreamName: "SQLStream", + Handler: _AeonRouterService_SQLStream_Handler, + ServerStreams: true, + }, + }, + Metadata: "aeon_router.proto", +} diff --git a/test/integration/aeon/server/service/server.go b/test/integration/aeon/server/service/server.go new file mode 100644 index 000000000..54a2021e6 --- /dev/null +++ b/test/integration/aeon/server/service/server.go @@ -0,0 +1,75 @@ +package service + +import ( + "context" + "mock/server/aeon/pb" + "strings" +) + +// Server mock functions: SQL[Check|Stream] accepts SQL request with string ["ok", "error", ""]. +// SQLCheck returns appropriate SQLCheckStatus value: "VALID", "INVALID", "INCOMPLETE". +// SQL[Stream] returns SQLResponse with two tuples on "ok" request and with Error other way. +type Server struct { + pb.UnimplementedAeonRouterServiceServer +} + +func (s *Server) Ping(ctx context.Context, in *pb.PingRequest) (*pb.PingResponse, error) { + return &pb.PingResponse{}, nil +} + +func (s *Server) SQLCheck(ctx context.Context, + request *pb.SQLRequest) (*pb.SQLCheckResponse, error) { + status := pb.SQLCheckStatus_SQL_QUERY_INCOMPLETE + switch strings.ToLower(request.Query) { + case "ok": + status = pb.SQLCheckStatus_SQL_QUERY_VALID + case "error": + status = pb.SQLCheckStatus_SQL_QUERY_INVALID + } + return &pb.SQLCheckResponse{Status: status}, nil +} + +func (s *Server) SQL(ctx context.Context, in *pb.SQLRequest) (*pb.SQLResponse, error) { + res := makeSQLResponse(in.Query) + return &res, nil +} + +func (s *Server) SQLStream(in *pb.SQLRequest, stream pb.AeonRouterService_SQLStreamServer) error { + res := makeSQLResponse(in.Query) + stream.Send(&res) + return nil +} + +func makeSQLResponse(query string) pb.SQLResponse { + switch strings.ToLower(query) { + case "ok": + return pb.SQLResponse{ + TupleFormat: &pb.TupleFormat{Names: []string{"id", "name"}}, + Tuples: []*pb.Tuple{ + { + Fields: []*pb.Value{ + {Kind: &pb.Value_IntegerValue{IntegerValue: 1}}, + {Kind: &pb.Value_StringValue{StringValue: "entry1"}}, + }, + }, + { + Fields: []*pb.Value{ + {Kind: &pb.Value_IntegerValue{IntegerValue: 2}}, + {Kind: &pb.Value_StringValue{StringValue: "entry2"}}, + }, + }, + }, + } + case "error": + return pb.SQLResponse{Error: &pb.Error{ + Type: "AeonSQLError", + Name: "SYNTAX_ERROR", + Msg: "error in mock SQL request", + }} + } + return pb.SQLResponse{Error: &pb.Error{ + Type: "AeonError", + Name: "UNEXPECTED_ERROR", + Msg: "incomplete in mock SQL request", + }} +} diff --git a/test/integration/aeon/test_aeon.py b/test/integration/aeon/test_aeon.py index faeb567cb..67bea63c0 100644 --- a/test/integration/aeon/test_aeon.py +++ b/test/integration/aeon/test_aeon.py @@ -1,15 +1,10 @@ #!/usr/bin/env python3 -from pathlib import Path from subprocess import PIPE, STDOUT, run import pytest AeonConnectCommand = ("aeon", "connect") -FormatData = { - "testdata": Path(__file__).parent / "testdata", -} - @pytest.mark.parametrize( "args", @@ -21,28 +16,33 @@ ("--transport", "plain", "--sslkeyfile", "not-exits.key"), ("--transport", "plain", "--sslcertfile", "not-exits.key"), ("--transport", "plain", "--sslcafile", "not-exits.key"), - ("--transport", "plain", "--sslkeyfile", "{testdata}/private.key"), - ("--transport", "plain", "--sslcertfile", "{testdata}/certfile.key"), - ("--transport", "plain", "--sslcafile", "{testdata}/ca.key"), - ( - "--sslkeyfile={testdata}/private.key", - "--sslcertfile={testdata}/certfile.key", - ), - ( - # "ssl" mode require existed path to files. - "--transport=ssl", - "--sslkeyfile={testdata}/private.key", - "--sslcertfile={testdata}/certfile.key", - "--sslcafile={testdata}/ca.key", - ), + ("--transport", "plain", "--sslkeyfile", "{c_private}"), + ("--transport", "plain", "--sslcertfile", "{c_public}"), + ("--transport", "plain", "--sslcafile", "{ca}"), ], ) -def test_cli_arguments_success(tt_cmd, args): - args = (a.format(**FormatData) for a in args) +def test_cli_plain_arguments_success(tt_cmd, aeon_plain, certificates, args): + args = (a.format(**certificates) for a in args) + print(f"aeon_server={aeon_plain}") result = run((tt_cmd, *AeonConnectCommand, *args)) assert result.returncode == 0 +def test_cli_ssl_arguments_success(tt_cmd, aeon_ssl, certificates): + cmd = [tt_cmd, *AeonConnectCommand, f"--sslcafile={certificates['ca']}"] + print(f"aeon ssl mode={aeon_ssl}") + if aeon_ssl == "mutual-tls": + cmd += ( + f"--sslkeyfile={certificates['c_private']}", + f"--sslcertfile={certificates['c_public']}", + ) + elif aeon_ssl == "server-side": + cmd += ("--transport", "ssl") + + result = run(cmd) + assert result.returncode == 0 + + @pytest.mark.parametrize( "args, error", [ @@ -54,25 +54,25 @@ def test_cli_arguments_success(tt_cmd, args): ( "--transport=ssl", "--sslkeyfile=not-exits.key", - "--sslcertfile={testdata}/certfile.key", - "--sslcafile={testdata}/ca.key", + "--sslcertfile={c_public}", + "--sslcafile={ca}", ), 'not valid path to a private SSL key file="not-exits.key"', ), ( ( "--transport=ssl", - "--sslkeyfile={testdata}/private.key", + "--sslkeyfile={c_private}", "--sslcertfile=not-exits.key", - "--sslcafile={testdata}/ca.key", + "--sslcafile={ca}", ), 'not valid path to an SSL certificate file="not-exits.key"', ), ( ( "--transport=ssl", - "--sslkeyfile={testdata}/private.key", - "--sslcertfile={testdata}/certfile.key", + "--sslkeyfile={c_private}", + "--sslcertfile={c_public}", "--sslcafile=not-exits.key", ), 'not valid path to trusted certificate authorities (CA) file="not-exits.key"', @@ -84,24 +84,24 @@ def test_cli_arguments_success(tt_cmd, args): ( ( "--transport=ssl", - "--sslcertfile={testdata}/certfile.key", - "--sslcafile={testdata}/ca.key", + "--sslcertfile={c_public}", + "--sslcafile={ca}", ), "files Key and Cert must be specified both", ), ( ( "--transport=ssl", - "--sslkeyfile={testdata}/private.key", - "--sslcafile={testdata}/ca.key", + "--sslkeyfile={c_private}", + "--sslcafile={ca}", ), "files Key and Cert must be specified both", ), ( ( "--transport=ssl", - "--sslcertfile={testdata}/certfile.key", - "--sslcafile={testdata}/ca.key", + "--sslcertfile={c_public}", + "--sslcafile={ca}", "--sslkeyfile", ), "flag needs an argument: --sslkeyfile", @@ -109,8 +109,8 @@ def test_cli_arguments_success(tt_cmd, args): ( ( "--transport=ssl", - "--sslkeyfile={testdata}/private.key", - "--sslcafile={testdata}/ca.key", + "--sslkeyfile={c_private}", + "--sslcafile={ca}", "--sslcertfile", ), "flag needs an argument: --sslcertfile", @@ -118,16 +118,16 @@ def test_cli_arguments_success(tt_cmd, args): ( ( "--transport=ssl", - "--sslkeyfile={testdata}/private.key", - "--sslcertfile={testdata}/certfile.key", + "--sslkeyfile={c_private}", + "--sslcertfile={c_public}", "--sslcafile", ), "flag needs an argument: --sslcafile", ), ], ) -def test_cli_arguments_fail(tt_cmd, args, error): - args = (a.format(**FormatData) for a in args) +def test_cli_arguments_fail(tt_cmd, certificates, args, error): + args = (a.format(**certificates) for a in args) result = run( (tt_cmd, *AeonConnectCommand, *args), stderr=STDOUT, diff --git a/test/integration/aeon/testdata/ca.key b/test/integration/aeon/testdata/ca.key deleted file mode 100644 index 93d503f39..000000000 --- a/test/integration/aeon/testdata/ca.key +++ /dev/null @@ -1 +0,0 @@ -# trusted certificate authorities (CA) file diff --git a/test/integration/aeon/testdata/certfile.key b/test/integration/aeon/testdata/certfile.key deleted file mode 100644 index eb26018b7..000000000 --- a/test/integration/aeon/testdata/certfile.key +++ /dev/null @@ -1 +0,0 @@ -# SSL certificate file diff --git a/test/integration/aeon/testdata/private.key b/test/integration/aeon/testdata/private.key deleted file mode 100644 index 522386ee1..000000000 --- a/test/integration/aeon/testdata/private.key +++ /dev/null @@ -1 +0,0 @@ -# private SSL key file