From cd52adc18b7bab7c3737a6db0a95adbf59009682 Mon Sep 17 00:00:00 2001 From: dragondriver Date: Fri, 22 Jan 2021 12:57:23 +0800 Subject: [PATCH] Add proxy service to ci workflow Signed-off-by: dragondriver --- .jenkins/modules/Publish/Publish.groovy | 4 + .../Regression/PythonRegression.groovy | 1 + Makefile | 4 + build/docker/deploy/.env | 2 + build/docker/deploy/docker-compose.yml | 14 +- build/docker/deploy/proxyservice/DockerFile | 22 + build/docker/test/docker-compose.yml | 2 +- cmd/proxy/service/proxy_service.go | 59 ++ cmd/singlenode/main.go | 12 +- configs/milvus.yaml | 1 - internal/core/src/pb/milvus.pb.cc | 504 +++++++++++++++--- internal/core/src/pb/milvus.pb.h | 246 ++++++++- internal/distributed/proxynode/service.go | 96 ++-- internal/distributed/proxyservice/client.go | 52 ++ .../distributed/proxyservice/paramtable.go | 46 ++ internal/distributed/proxyservice/service.go | 84 +++ internal/proto/milvus.proto | 9 + internal/proto/milvuspb/milvus.pb.go | 326 +++++++---- internal/proto/proxy_service.proto | 6 +- internal/proto/proxypb/proxy_service.pb.go | 131 ++--- internal/proxynode/paramtable.go | 6 + internal/proxynode/proxy_node.go | 9 +- internal/proxyservice/impl.go | 145 +++++ internal/proxyservice/interface.go | 19 + internal/proxyservice/node_info.go | 116 ++++ internal/proxyservice/nodeid_allocator.go | 33 ++ internal/proxyservice/proxyservice.go | 63 +-- internal/proxyservice/task.go | 157 ++++++ internal/proxyservice/task_queue.go | 92 ++++ internal/proxyservice/task_scheduler.go | 119 +++++ internal/proxyservice/utils.go | 21 + tests/python/requirements.txt | 2 +- 32 files changed, 2036 insertions(+), 367 deletions(-) create mode 100644 build/docker/deploy/proxyservice/DockerFile create mode 100644 cmd/proxy/service/proxy_service.go create mode 100644 internal/distributed/proxyservice/client.go create mode 100644 internal/distributed/proxyservice/paramtable.go create mode 100644 internal/distributed/proxyservice/service.go create mode 100644 internal/proxyservice/impl.go create mode 100644 internal/proxyservice/interface.go create mode 100644 internal/proxyservice/node_info.go create mode 100644 internal/proxyservice/nodeid_allocator.go create mode 100644 internal/proxyservice/task.go create mode 100644 internal/proxyservice/task_queue.go create mode 100644 internal/proxyservice/task_scheduler.go create mode 100644 internal/proxyservice/utils.go diff --git a/.jenkins/modules/Publish/Publish.groovy b/.jenkins/modules/Publish/Publish.groovy index fd8f25d0a8..2f96fe4c7b 100644 --- a/.jenkins/modules/Publish/Publish.groovy +++ b/.jenkins/modules/Publish/Publish.groovy @@ -21,6 +21,10 @@ dir ('build/docker/deploy') { sh 'docker-compose build --force-rm indexbuilder' sh 'docker-compose push indexbuilder' + sh 'docker pull ${SOURCE_REPO}/proxyservice:${SOURCE_TAG} || true' + sh 'docker-compose build --force-rm proxyservice' + sh 'docker-compose push proxyservice' + sh 'docker pull ${SOURCE_REPO}/proxynode:${SOURCE_TAG} || true' sh 'docker-compose build --force-rm proxynode' sh 'docker-compose push proxynode' diff --git a/.jenkins/modules/Regression/PythonRegression.groovy b/.jenkins/modules/Regression/PythonRegression.groovy index d5259b44fd..4d7a9ae238 100644 --- a/.jenkins/modules/Regression/PythonRegression.groovy +++ b/.jenkins/modules/Regression/PythonRegression.groovy @@ -7,6 +7,7 @@ try { sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} pull' sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} up -d master' sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} up -d indexbuilder' + sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} up -d proxyservice' sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} up -d proxynode' sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} run -e QUERY_NODE_ID=1 -d querynode' sh 'docker-compose -p ${DOCKER_COMPOSE_PROJECT_NAME} run -e QUERY_NODE_ID=2 -d querynode' diff --git a/Makefile b/Makefile index be19d6841d..7d5c02d842 100644 --- a/Makefile +++ b/Makefile @@ -113,6 +113,8 @@ build-go: build-cpp @echo "Building each component's binary to './bin'" @echo "Building master ..." @mkdir -p $(INSTALL_PATH) && go env -w CGO_ENABLED="0" && GO111MODULE=on $(GO) build -o $(INSTALL_PATH)/master $(PWD)/cmd/master/main.go 1>/dev/null + @echo "Building proxy service ..." + @mkdir -p $(INSTALL_PATH) && go env -w CGO_ENABLED="0" && GO111MODULE=on $(GO) build -o $(INSTALL_PATH)/proxyservice $(PWD)/cmd/proxy/service/proxy_service.go 1>/dev/null @echo "Building proxy node ..." @mkdir -p $(INSTALL_PATH) && go env -w CGO_ENABLED="0" && GO111MODULE=on $(GO) build -o $(INSTALL_PATH)/proxynode $(PWD)/cmd/proxy/node/proxy_node.go 1>/dev/null @echo "Building query node ..." @@ -166,6 +168,7 @@ install: all @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/querynode $(GOPATH)/bin/querynode @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/master $(GOPATH)/bin/master @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/proxynode $(GOPATH)/bin/proxynode + @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/proxyservice $(GOPATH)/bin/proxyservice @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/writenode $(GOPATH)/bin/writenode @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/indexbuilder $(GOPATH)/bin/indexbuilder @mkdir -p $(GOPATH)/bin && cp -f $(PWD)/bin/singlenode $(GOPATH)/bin/singlenode @@ -180,6 +183,7 @@ clean: @rm -rf lib/ @rm -rf $(GOPATH)/bin/master @rm -rf $(GOPATH)/bin/proxynode + @rm -rf $(GOPATH)/bin/proxyservice @rm -rf $(GOPATH)/bin/querynode @rm -rf $(GOPATH)/bin/writenode @rm -rf $(GOPATH)/bin/indexbuilder diff --git a/build/docker/deploy/.env b/build/docker/deploy/.env index 5ce139901f..60e048725d 100644 --- a/build/docker/deploy/.env +++ b/build/docker/deploy/.env @@ -7,3 +7,5 @@ ETCD_ADDRESS=etcd:2379 MASTER_ADDRESS=master:53100 MINIO_ADDRESS=minio:9000 INDEX_BUILDER_ADDRESS=indexbuilder:31000 +PROXY_NODE_HOST=proxynode +PROXY_SERVICE_ADDRESS=proxyservice:19530 diff --git a/build/docker/deploy/docker-compose.yml b/build/docker/deploy/docker-compose.yml index 394c90237e..eb9e001efd 100644 --- a/build/docker/deploy/docker-compose.yml +++ b/build/docker/deploy/docker-compose.yml @@ -15,6 +15,16 @@ services: networks: - milvus + proxyservice: + image: ${TARGET_REPO}/proxyservice:${TARGET_TAG} + build: + context: ../../../ + dockerfile: build/docker/deploy/proxyservice/DockerFile + cache_from: + - ${SOURCE_REPO}/proxyservice:${SOURCE_TAG} + networks: + - milvus + proxynode: image: ${TARGET_REPO}/proxynode:${TARGET_TAG} build: @@ -25,7 +35,9 @@ services: environment: PULSAR_ADDRESS: ${PULSAR_ADDRESS} MASTER_ADDRESS: ${MASTER_ADDRESS} - networks: + PROXY_NODE_HOST: ${PROXY_NODE_HOST} + PROXY_SERVICE_ADDRESS: ${PROXY_SERVICE_ADDRESS} + networks: - milvus indexbuilder: diff --git a/build/docker/deploy/proxyservice/DockerFile b/build/docker/deploy/proxyservice/DockerFile new file mode 100644 index 0000000000..88cb93855e --- /dev/null +++ b/build/docker/deploy/proxyservice/DockerFile @@ -0,0 +1,22 @@ +# Copyright (C) 2019-2020 Zilliz. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software distributed under the License +# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +# or implied. See the License for the specific language governing permissions and limitations under the License. + +FROM alpine:3.12.1 + +COPY ./bin/proxyservice /milvus-distributed/bin/proxyservice + +COPY ./configs/ /milvus-distributed/configs/ + +WORKDIR /milvus-distributed/ + +CMD ["./bin/proxyservice"] + +EXPOSE 19530 diff --git a/build/docker/test/docker-compose.yml b/build/docker/test/docker-compose.yml index 21d61f4c43..67a2be03b7 100644 --- a/build/docker/test/docker-compose.yml +++ b/build/docker/test/docker-compose.yml @@ -12,7 +12,7 @@ services: - ../../..:/milvus-distributed:delegated working_dir: "/milvus-distributed/tests/python" command: > - /bin/bash -c "pytest --ip proxynode" + /bin/bash -c "pytest --ip proxyservice" networks: - milvus diff --git a/cmd/proxy/service/proxy_service.go b/cmd/proxy/service/proxy_service.go new file mode 100644 index 0000000000..ece3e98e7b --- /dev/null +++ b/cmd/proxy/service/proxy_service.go @@ -0,0 +1,59 @@ +package main + +import ( + "context" + "log" + "os" + "os/signal" + "syscall" + + grpcproxyservice "github.com/zilliztech/milvus-distributed/internal/distributed/proxyservice" + + "go.uber.org/zap" +) + +func main() { + ctx, cancel := context.WithCancel(context.Background()) + svr, err := grpcproxyservice.CreateProxyServiceServer() + if err != nil { + log.Print("create server failed", zap.Error(err)) + } + + sc := make(chan os.Signal, 1) + signal.Notify(sc, + syscall.SIGHUP, + syscall.SIGINT, + syscall.SIGTERM, + syscall.SIGQUIT) + + var sig os.Signal + go func() { + sig = <-sc + cancel() + }() + + if err := svr.Init(); err != nil { + log.Fatal("init server failed", zap.Error(err)) + } + + if err := svr.Start(); err != nil { + log.Fatal("run server failed", zap.Error(err)) + } + + <-ctx.Done() + log.Print("Got signal to exit", zap.String("signal", sig.String())) + + if err := svr.Stop(); err != nil { + log.Fatal("stop server failed", zap.Error(err)) + } + switch sig { + case syscall.SIGTERM: + exit(0) + default: + exit(1) + } +} + +func exit(code int) { + os.Exit(code) +} diff --git a/cmd/singlenode/main.go b/cmd/singlenode/main.go index 90cba0b75d..4a831a9fde 100644 --- a/cmd/singlenode/main.go +++ b/cmd/singlenode/main.go @@ -16,7 +16,7 @@ import ( "github.com/zilliztech/milvus-distributed/internal/indexnode" "github.com/zilliztech/milvus-distributed/internal/master" - proxynodeimpl "github.com/zilliztech/milvus-distributed/internal/proxynode" + "github.com/zilliztech/milvus-distributed/internal/proxynode" "github.com/zilliztech/milvus-distributed/internal/querynode" "github.com/zilliztech/milvus-distributed/internal/writenode" ) @@ -62,10 +62,10 @@ func InitMaster(cpuprofile *string, wg *sync.WaitGroup) { func InitProxy(wg *sync.WaitGroup) { defer wg.Done() - //proxynodeimpl.Init() - //fmt.Println("ProxyID is", proxynodeimpl.Params.ProxyID()) + //proxynode.Init() + //fmt.Println("ProxyID is", proxynode.Params.ProxyID()) ctx, cancel := context.WithCancel(context.Background()) - svr, err := proxynodeimpl.CreateProxyNodeImpl(ctx) + svr, err := proxynode.CreateProxyNodeImpl(ctx) if err != nil { log.Print("create server failed", zap.Error(err)) } @@ -220,9 +220,13 @@ func main() { wg.Add(1) go InitMaster(cpuprofile, &wg) time.Sleep(time.Second * 1) + wg.Add(1) go InitProxy(&wg) + wg.Add(1) go InitQueryNode(&wg) + wg.Add(1) go InitIndexBuilder(&wg) + wg.Add(1) go InitWriteNode(&wg) wg.Wait() } diff --git a/configs/milvus.yaml b/configs/milvus.yaml index 70abb5d82c..d3a21ad6eb 100644 --- a/configs/milvus.yaml +++ b/configs/milvus.yaml @@ -51,7 +51,6 @@ proxyNode: address: localhost port: 19530 -# not used now proxyService: address: localhost port: 19530 diff --git a/internal/core/src/pb/milvus.pb.cc b/internal/core/src/pb/milvus.pb.cc index 57d358abd0..c65e4586a1 100644 --- a/internal/core/src/pb/milvus.pb.cc +++ b/internal/core/src/pb/milvus.pb.cc @@ -15,6 +15,7 @@ #include // @@protoc_insertion_point(includes) #include +extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Address_common_2eproto; extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Blob_common_2eproto; extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_common_2eproto; extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MsgBase_common_2eproto; @@ -185,6 +186,10 @@ class FlushRequestDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _FlushRequest_default_instance_; +class RegisterLinkResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RegisterLinkResponse_default_instance_; } // namespace milvus } // namespace proto } // namespace milvus @@ -627,6 +632,22 @@ static void InitDefaultsscc_info_PlaceholderValue_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlaceholderValue_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_PlaceholderValue_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_RegisterLinkResponse_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_RegisterLinkResponse_default_instance_; + new (ptr) ::milvus::proto::milvus::RegisterLinkResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::RegisterLinkResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RegisterLinkResponse_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RegisterLinkResponse_milvus_2eproto}, { + &scc_info_Address_common_2eproto.base, + &scc_info_Status_common_2eproto.base,}}; + static void InitDefaultsscc_info_ReleaseCollectionRequest_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -792,7 +813,7 @@ static void InitDefaultsscc_info_StringResponse_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringResponse_milvus_2eproto}, { &scc_info_Status_common_2eproto.base,}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[40]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[41]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[1]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; @@ -1122,6 +1143,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, base_), PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, db_name_), PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, collection_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, address_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, status_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::milvus::proto::milvus::CreateCollectionRequest)}, @@ -1164,6 +1192,7 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 302, -1, sizeof(::milvus::proto::milvus::Hits)}, { 310, -1, sizeof(::milvus::proto::milvus::SearchResults)}, { 317, -1, sizeof(::milvus::proto::milvus::FlushRequest)}, + { 325, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1207,6 +1236,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::proto::milvus::_Hits_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_SearchResults_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_FlushRequest_default_instance_), + reinterpret_cast(&::milvus::proto::milvus::_RegisterLinkResponse_default_instance_), }; const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = @@ -1328,71 +1358,76 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "(\0132\033.milvus.proto.common.Status\022\014\n\004hits\030" "\002 \003(\014\"d\n\014FlushRequest\022*\n\004base\030\001 \001(\0132\034.mi" "lvus.proto.common.MsgBase\022\017\n\007db_name\030\002 \001" - "(\t\022\027\n\017collection_name\030\003 \001(\t*@\n\017Placehold" - "erType\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014V" - "ECTOR_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020Creat" - "eCollection\022,.milvus.proto.milvus.Create" - "CollectionRequest\032\033.milvus.proto.common." - "Status\"\000\022[\n\016DropCollection\022*.milvus.prot" - "o.milvus.DropCollectionRequest\032\033.milvus." - "proto.common.Status\"\000\022_\n\rHasCollection\022)" - ".milvus.proto.milvus.HasCollectionReques" - "t\032!.milvus.proto.milvus.BoolResponse\"\000\022[" - "\n\016LoadCollection\022*.milvus.proto.milvus.L" - "oadCollectionRequest\032\033.milvus.proto.comm" - "on.Status\"\000\022a\n\021ReleaseCollection\022-.milvu" - "s.proto.milvus.ReleaseCollectionRequest\032" - "\033.milvus.proto.common.Status\"\000\022w\n\022Descri" - "beCollection\022..milvus.proto.milvus.Descr" - "ibeCollectionRequest\032/.milvus.proto.milv" - "us.DescribeCollectionResponse\"\000\022v\n\027GetCo" - "llectionStatistics\022+.milvus.proto.milvus" - ".CollectionStatsRequest\032,.milvus.proto.m" - "ilvus.CollectionStatsResponse\"\000\022l\n\017ShowC" - "ollections\022*.milvus.proto.milvus.ShowCol" - "lectionRequest\032+.milvus.proto.milvus.Sho" - "wCollectionResponse\"\000\022]\n\017CreatePartition" - "\022+.milvus.proto.milvus.CreatePartitionRe" - "quest\032\033.milvus.proto.common.Status\"\000\022Y\n\r" - "DropPartition\022).milvus.proto.milvus.Drop" + "(\t\022\027\n\017collection_name\030\003 \001(\t\"r\n\024RegisterL" + "inkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pr" + "oto.common.Address\022+\n\006status\030\002 \001(\0132\033.mil" + "vus.proto.common.Status*@\n\017PlaceholderTy" + "pe\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTO" + "R_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateCol" + "lection\022,.milvus.proto.milvus.CreateColl" + "ectionRequest\032\033.milvus.proto.common.Stat" + "us\"\000\022[\n\016DropCollection\022*.milvus.proto.mi" + "lvus.DropCollectionRequest\032\033.milvus.prot" + "o.common.Status\"\000\022_\n\rHasCollection\022).mil" + "vus.proto.milvus.HasCollectionRequest\032!." + "milvus.proto.milvus.BoolResponse\"\000\022[\n\016Lo" + "adCollection\022*.milvus.proto.milvus.LoadC" + "ollectionRequest\032\033.milvus.proto.common.S" + "tatus\"\000\022a\n\021ReleaseCollection\022-.milvus.pr" + "oto.milvus.ReleaseCollectionRequest\032\033.mi" + "lvus.proto.common.Status\"\000\022w\n\022DescribeCo" + "llection\022..milvus.proto.milvus.DescribeC" + "ollectionRequest\032/.milvus.proto.milvus.D" + "escribeCollectionResponse\"\000\022v\n\027GetCollec" + "tionStatistics\022+.milvus.proto.milvus.Col" + "lectionStatsRequest\032,.milvus.proto.milvu" + "s.CollectionStatsResponse\"\000\022l\n\017ShowColle" + "ctions\022*.milvus.proto.milvus.ShowCollect" + "ionRequest\032+.milvus.proto.milvus.ShowCol" + "lectionResponse\"\000\022]\n\017CreatePartition\022+.m" + "ilvus.proto.milvus.CreatePartitionReques" + "t\032\033.milvus.proto.common.Status\"\000\022Y\n\rDrop" + "Partition\022).milvus.proto.milvus.DropPart" + "itionRequest\032\033.milvus.proto.common.Statu" + "s\"\000\022]\n\014HasPartition\022(.milvus.proto.milvu" + "s.HasPartitionRequest\032!.milvus.proto.mil" + "vus.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.m" + "ilvus.proto.milvus.LoadPartitonRequest\032\033" + ".milvus.proto.common.Status\"\000\022`\n\021Release" + "Partitions\022,.milvus.proto.milvus.Release" "PartitionRequest\032\033.milvus.proto.common.S" - "tatus\"\000\022]\n\014HasPartition\022(.milvus.proto.m" - "ilvus.HasPartitionRequest\032!.milvus.proto" - ".milvus.BoolResponse\"\000\022Y\n\016LoadPartitions" - "\022(.milvus.proto.milvus.LoadPartitonReque" - "st\032\033.milvus.proto.common.Status\"\000\022`\n\021Rel" - "easePartitions\022,.milvus.proto.milvus.Rel" - "easePartitionRequest\032\033.milvus.proto.comm" - "on.Status\"\000\022s\n\026GetPartitionStatistics\022*." - "milvus.proto.milvus.PartitionStatsReques" - "t\032+.milvus.proto.milvus.PartitionStatsRe" - "sponse\"\000\022i\n\016ShowPartitions\022).milvus.prot" - "o.milvus.ShowPartitionRequest\032*.milvus.p" - "roto.milvus.ShowPartitionResponse\"\000\022U\n\013C" - "reateIndex\022\'.milvus.proto.milvus.CreateI" - "ndexRequest\032\033.milvus.proto.common.Status" - "\"\000\022h\n\rDescribeIndex\022).milvus.proto.milvu" - "s.DescribeIndexRequest\032*.milvus.proto.mi" - "lvus.DescribeIndexResponse\"\000\022b\n\rGetIndex" - "State\022&.milvus.proto.milvus.IndexStateRe" - "quest\032\'.milvus.proto.milvus.IndexStateRe" - "sponse\"\000\022S\n\006Insert\022\".milvus.proto.milvus" - ".InsertRequest\032#.milvus.proto.milvus.Ins" - "ertResponse\"\000\022R\n\006Search\022\".milvus.proto.m" - "ilvus.SearchRequest\032\".milvus.proto.milvu" - "s.SearchResults\"\000\022I\n\005Flush\022!.milvus.prot" - "o.milvus.FlushRequest\032\033.milvus.proto.com" - "mon.Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.pr" - "oto.common.Empty\032#.milvus.proto.milvus.S" - "tringResponse\"\000BBZ@github.com/zilliztech" - "/milvus-distributed/internal/proto/milvu" - "spbb\006proto3" + "tatus\"\000\022s\n\026GetPartitionStatistics\022*.milv" + "us.proto.milvus.PartitionStatsRequest\032+." + "milvus.proto.milvus.PartitionStatsRespon" + "se\"\000\022i\n\016ShowPartitions\022).milvus.proto.mi" + "lvus.ShowPartitionRequest\032*.milvus.proto" + ".milvus.ShowPartitionResponse\"\000\022U\n\013Creat" + "eIndex\022\'.milvus.proto.milvus.CreateIndex" + "Request\032\033.milvus.proto.common.Status\"\000\022h" + "\n\rDescribeIndex\022).milvus.proto.milvus.De" + "scribeIndexRequest\032*.milvus.proto.milvus" + ".DescribeIndexResponse\"\000\022b\n\rGetIndexStat" + "e\022&.milvus.proto.milvus.IndexStateReques" + "t\032\'.milvus.proto.milvus.IndexStateRespon" + "se\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Ins" + "ertRequest\032#.milvus.proto.milvus.InsertR" + "esponse\"\000\022R\n\006Search\022\".milvus.proto.milvu" + "s.SearchRequest\032\".milvus.proto.milvus.Se" + "archResults\"\000\022I\n\005Flush\022!.milvus.proto.mi" + "lvus.FlushRequest\032\033.milvus.proto.common." + "Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto." + "common.Empty\032#.milvus.proto.milvus.Strin" + "gResponse\"\0002g\n\014ProxyService\022W\n\014RegisterL" + "ink\022\032.milvus.proto.common.Empty\032).milvus" + ".proto.milvus.RegisterLinkResponse\"\000BBZ@" + "github.com/zilliztech/milvus-distributed" + "/internal/proto/milvuspbb\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = { &::descriptor_table_common_2eproto, &::descriptor_table_schema_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[40] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[41] = { &scc_info_BoolResponse_milvus_2eproto.base, &scc_info_CollectionStatsRequest_milvus_2eproto.base, &scc_info_CollectionStatsResponse_milvus_2eproto.base, @@ -1422,6 +1457,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_PartitionStatsResponse_milvus_2eproto.base, &scc_info_PlaceholderGroup_milvus_2eproto.base, &scc_info_PlaceholderValue_milvus_2eproto.base, + &scc_info_RegisterLinkResponse_milvus_2eproto.base, &scc_info_ReleaseCollectionRequest_milvus_2eproto.base, &scc_info_ReleasePartitionRequest_milvus_2eproto.base, &scc_info_SearchRequest_milvus_2eproto.base, @@ -1437,10 +1473,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7051, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 40, 2, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7272, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 41, 2, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 40, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 41, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -17396,6 +17432,345 @@ void FlushRequest::InternalSwap(FlushRequest* other) { } +// =================================================================== + +void RegisterLinkResponse::InitAsDefaultInstance() { + ::milvus::proto::milvus::_RegisterLinkResponse_default_instance_._instance.get_mutable()->address_ = const_cast< ::milvus::proto::common::Address*>( + ::milvus::proto::common::Address::internal_default_instance()); + ::milvus::proto::milvus::_RegisterLinkResponse_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::proto::common::Status*>( + ::milvus::proto::common::Status::internal_default_instance()); +} +class RegisterLinkResponse::_Internal { + public: + static const ::milvus::proto::common::Address& address(const RegisterLinkResponse* msg); + static const ::milvus::proto::common::Status& status(const RegisterLinkResponse* msg); +}; + +const ::milvus::proto::common::Address& +RegisterLinkResponse::_Internal::address(const RegisterLinkResponse* msg) { + return *msg->address_; +} +const ::milvus::proto::common::Status& +RegisterLinkResponse::_Internal::status(const RegisterLinkResponse* msg) { + return *msg->status_; +} +void RegisterLinkResponse::clear_address() { + if (GetArenaNoVirtual() == nullptr && address_ != nullptr) { + delete address_; + } + address_ = nullptr; +} +void RegisterLinkResponse::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +RegisterLinkResponse::RegisterLinkResponse() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.RegisterLinkResponse) +} +RegisterLinkResponse::RegisterLinkResponse(const RegisterLinkResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_address()) { + address_ = new ::milvus::proto::common::Address(*from.address_); + } else { + address_ = nullptr; + } + if (from.has_status()) { + status_ = new ::milvus::proto::common::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.RegisterLinkResponse) +} + +void RegisterLinkResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RegisterLinkResponse_milvus_2eproto.base); + ::memset(&address_, 0, static_cast( + reinterpret_cast(&status_) - + reinterpret_cast(&address_)) + sizeof(status_)); +} + +RegisterLinkResponse::~RegisterLinkResponse() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.RegisterLinkResponse) + SharedDtor(); +} + +void RegisterLinkResponse::SharedDtor() { + if (this != internal_default_instance()) delete address_; + if (this != internal_default_instance()) delete status_; +} + +void RegisterLinkResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RegisterLinkResponse& RegisterLinkResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RegisterLinkResponse_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void RegisterLinkResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.RegisterLinkResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaNoVirtual() == nullptr && address_ != nullptr) { + delete address_; + } + address_ = nullptr; + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RegisterLinkResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .milvus.proto.common.Address address = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_address(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.proto.common.Status status = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool RegisterLinkResponse::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.proto.milvus.RegisterLinkResponse) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .milvus.proto.common.Address address = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_address())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.common.Status status = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.proto.milvus.RegisterLinkResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.RegisterLinkResponse) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RegisterLinkResponse::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.RegisterLinkResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.Address address = 1; + if (this->has_address()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::address(this), output); + } + + // .milvus.proto.common.Status status = 2; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::status(this), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.proto.milvus.RegisterLinkResponse) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RegisterLinkResponse::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.RegisterLinkResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.Address address = 1; + if (this->has_address()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::address(this), target); + } + + // .milvus.proto.common.Status status = 2; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::status(this), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.milvus.RegisterLinkResponse) + return target; +} + +size_t RegisterLinkResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.RegisterLinkResponse) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .milvus.proto.common.Address address = 1; + if (this->has_address()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *address_); + } + + // .milvus.proto.common.Status status = 2; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RegisterLinkResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.RegisterLinkResponse) + GOOGLE_DCHECK_NE(&from, this); + const RegisterLinkResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.RegisterLinkResponse) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.RegisterLinkResponse) + MergeFrom(*source); + } +} + +void RegisterLinkResponse::MergeFrom(const RegisterLinkResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.RegisterLinkResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_address()) { + mutable_address()->::milvus::proto::common::Address::MergeFrom(from.address()); + } + if (from.has_status()) { + mutable_status()->::milvus::proto::common::Status::MergeFrom(from.status()); + } +} + +void RegisterLinkResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.RegisterLinkResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RegisterLinkResponse::CopyFrom(const RegisterLinkResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.RegisterLinkResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RegisterLinkResponse::IsInitialized() const { + return true; +} + +void RegisterLinkResponse::InternalSwap(RegisterLinkResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(address_, other->address_); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RegisterLinkResponse::GetMetadata() const { + return GetMetadataStatic(); +} + + // @@protoc_insertion_point(namespace_scope) } // namespace milvus } // namespace proto @@ -17521,6 +17896,9 @@ template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::SearchResults* Arena::Crea template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::FlushRequest* Arena::CreateMaybeMessage< ::milvus::proto::milvus::FlushRequest >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::milvus::FlushRequest >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage< ::milvus::proto::milvus::RegisterLinkResponse >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::RegisterLinkResponse >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/internal/core/src/pb/milvus.pb.h b/internal/core/src/pb/milvus.pb.h index b474b5ca32..fd837d0269 100644 --- a/internal/core/src/pb/milvus.pb.h +++ b/internal/core/src/pb/milvus.pb.h @@ -50,7 +50,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[40] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[41] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -147,6 +147,9 @@ extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_; class PlaceholderValue; class PlaceholderValueDefaultTypeInternal; extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_; +class RegisterLinkResponse; +class RegisterLinkResponseDefaultTypeInternal; +extern RegisterLinkResponseDefaultTypeInternal _RegisterLinkResponse_default_instance_; class ReleaseCollectionRequest; class ReleaseCollectionRequestDefaultTypeInternal; extern ReleaseCollectionRequestDefaultTypeInternal _ReleaseCollectionRequest_default_instance_; @@ -213,6 +216,7 @@ template<> ::milvus::proto::milvus::PartitionStatsRequest* Arena::CreateMaybeMes template<> ::milvus::proto::milvus::PartitionStatsResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::PartitionStatsResponse>(Arena*); template<> ::milvus::proto::milvus::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderGroup>(Arena*); template<> ::milvus::proto::milvus::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderValue>(Arena*); +template<> ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkResponse>(Arena*); template<> ::milvus::proto::milvus::ReleaseCollectionRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleaseCollectionRequest>(Arena*); template<> ::milvus::proto::milvus::ReleasePartitionRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::ReleasePartitionRequest>(Arena*); template<> ::milvus::proto::milvus::SearchRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::SearchRequest>(Arena*); @@ -6716,6 +6720,150 @@ class FlushRequest : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; +// ------------------------------------------------------------------- + +class RegisterLinkResponse : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.RegisterLinkResponse) */ { + public: + RegisterLinkResponse(); + virtual ~RegisterLinkResponse(); + + RegisterLinkResponse(const RegisterLinkResponse& from); + RegisterLinkResponse(RegisterLinkResponse&& from) noexcept + : RegisterLinkResponse() { + *this = ::std::move(from); + } + + inline RegisterLinkResponse& operator=(const RegisterLinkResponse& from) { + CopyFrom(from); + return *this; + } + inline RegisterLinkResponse& operator=(RegisterLinkResponse&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const RegisterLinkResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RegisterLinkResponse* internal_default_instance() { + return reinterpret_cast( + &_RegisterLinkResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(RegisterLinkResponse& a, RegisterLinkResponse& b) { + a.Swap(&b); + } + inline void Swap(RegisterLinkResponse* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RegisterLinkResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + RegisterLinkResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RegisterLinkResponse& from); + void MergeFrom(const RegisterLinkResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RegisterLinkResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.RegisterLinkResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAddressFieldNumber = 1, + kStatusFieldNumber = 2, + }; + // .milvus.proto.common.Address address = 1; + bool has_address() const; + void clear_address(); + const ::milvus::proto::common::Address& address() const; + ::milvus::proto::common::Address* release_address(); + ::milvus::proto::common::Address* mutable_address(); + void set_allocated_address(::milvus::proto::common::Address* address); + + // .milvus.proto.common.Status status = 2; + bool has_status() const; + void clear_status(); + const ::milvus::proto::common::Status& status() const; + ::milvus::proto::common::Status* release_status(); + ::milvus::proto::common::Status* mutable_status(); + void set_allocated_status(::milvus::proto::common::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.proto.milvus.RegisterLinkResponse) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::milvus::proto::common::Address* address_; + ::milvus::proto::common::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; // =================================================================== @@ -12474,6 +12622,100 @@ inline void FlushRequest::set_allocated_collection_name(std::string* collection_ // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.FlushRequest.collection_name) } +// ------------------------------------------------------------------- + +// RegisterLinkResponse + +// .milvus.proto.common.Address address = 1; +inline bool RegisterLinkResponse::has_address() const { + return this != internal_default_instance() && address_ != nullptr; +} +inline const ::milvus::proto::common::Address& RegisterLinkResponse::address() const { + const ::milvus::proto::common::Address* p = address_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.RegisterLinkResponse.address) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_Address_default_instance_); +} +inline ::milvus::proto::common::Address* RegisterLinkResponse::release_address() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.RegisterLinkResponse.address) + + ::milvus::proto::common::Address* temp = address_; + address_ = nullptr; + return temp; +} +inline ::milvus::proto::common::Address* RegisterLinkResponse::mutable_address() { + + if (address_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::Address>(GetArenaNoVirtual()); + address_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RegisterLinkResponse.address) + return address_; +} +inline void RegisterLinkResponse::set_allocated_address(::milvus::proto::common::Address* address) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(address_); + } + if (address) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + address = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, address, submessage_arena); + } + + } else { + + } + address_ = address; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RegisterLinkResponse.address) +} + +// .milvus.proto.common.Status status = 2; +inline bool RegisterLinkResponse::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::proto::common::Status& RegisterLinkResponse::status() const { + const ::milvus::proto::common::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.RegisterLinkResponse.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_Status_default_instance_); +} +inline ::milvus::proto::common::Status* RegisterLinkResponse::release_status() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.RegisterLinkResponse.status) + + ::milvus::proto::common::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::proto::common::Status* RegisterLinkResponse::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.RegisterLinkResponse.status) + return status_; +} +inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.RegisterLinkResponse.status) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -12555,6 +12797,8 @@ inline void FlushRequest::set_allocated_collection_name(std::string* collection_ // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/internal/distributed/proxynode/service.go b/internal/distributed/proxynode/service.go index adca967ec1..0b8584413f 100644 --- a/internal/distributed/proxynode/service.go +++ b/internal/distributed/proxynode/service.go @@ -3,13 +3,18 @@ package grpcproxynode import ( "context" "net" + "os" "strconv" "sync" + "github.com/go-basic/ipv4" + + grpcproxyservice "github.com/zilliztech/milvus-distributed/internal/distributed/proxyservice" + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" - proxynodeimpl "github.com/zilliztech/milvus-distributed/internal/proxynode" + "github.com/zilliztech/milvus-distributed/internal/proxynode" "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" @@ -19,12 +24,12 @@ import ( type Server struct { ctx context.Context wg sync.WaitGroup - impl proxynodeimpl.ProxyNode + impl proxynode.ProxyNode grpcServer *grpc.Server ip string port int proxyServiceAddress string - //proxyServiceClient *proxyservice.Client + proxyServiceClient *grpcproxyservice.Client } func CreateProxyNodeServer() (*Server, error) { @@ -32,51 +37,56 @@ func CreateProxyNodeServer() (*Server, error) { } func (s *Server) connectProxyService() error { - proxynodeimpl.Params.Init() + proxynode.Params.Init() - //s.proxyServiceAddress = proxynodeimpl.Params.ProxyServiceAddress() - //s.proxyServiceClient = proxyservice.NewClient(s.ctx, s.proxyServiceAddress) - // - //getAvailablePort := func() int { - // listener, err := net.Listen("tcp", ":0") - // if err != nil { - // panic(err) - // } - // defer listener.Close() - // - // return listener.Addr().(*net.TCPAddr).Port - //} - //getLocalIp := func() string { - // return ipv4.LocalIP() - //} - //s.ip = getLocalIp() - //s.port = getAvailablePort() - // - //request := &proxypb.RegisterNodeRequest{ - // Address: &commonpb.Address{ - // Ip: s.ip, - // Port: int64(s.port), - // }, - //} - //response, err := s.proxyServiceClient.RegisterNode(request) - //if err != nil { - // panic(err) - //} - // - //proxynodeimpl.Params.Save("_proxyID", strconv.Itoa(int(response.InitParams.NodeID))) - // - //for _, params := range response.InitParams.StartParams { - // proxynodeimpl.Params.Save(params.Key, params.Value) - //} - // - //return err - return nil + s.proxyServiceAddress = proxynode.Params.ProxyServiceAddress() + s.proxyServiceClient = grpcproxyservice.NewClient(s.ctx, s.proxyServiceAddress) + + getAvailablePort := func() int { + listener, err := net.Listen("tcp", ":0") + if err != nil { + panic(err) + } + defer listener.Close() + + return listener.Addr().(*net.TCPAddr).Port + } + getLocalIP := func() string { + localIP := ipv4.LocalIP() + host := os.Getenv("PROXY_NODE_HOST") + // TODO: shall we write this to ParamTable? + if len(host) <= 0 { + return localIP + } + return host + } + s.ip = getLocalIP() + s.port = getAvailablePort() + + request := &proxypb.RegisterNodeRequest{ + Address: &commonpb.Address{ + Ip: s.ip, + Port: int64(s.port), + }, + } + response, err := s.proxyServiceClient.RegisterNode(request) + if err != nil { + panic(err) + } + + proxynode.Params.Save("_proxyID", strconv.Itoa(int(response.InitParams.NodeID))) + + for _, params := range response.InitParams.StartParams { + proxynode.Params.Save(params.Key, params.Value) + } + + return err } func (s *Server) Init() error { s.ctx = context.Background() var err error - s.impl, err = proxynodeimpl.CreateProxyNodeImpl(s.ctx) + s.impl, err = proxynode.CreateProxyNodeImpl(s.ctx) if err != nil { return err } @@ -93,7 +103,7 @@ func (s *Server) Start() error { defer s.wg.Done() // TODO: use config - lis, err := net.Listen("tcp", ":"+strconv.Itoa(proxynodeimpl.Params.NetworkPort())) + lis, err := net.Listen("tcp", ":"+strconv.Itoa(s.port)) if err != nil { panic(err) } diff --git a/internal/distributed/proxyservice/client.go b/internal/distributed/proxyservice/client.go new file mode 100644 index 0000000000..1b16c5e1e6 --- /dev/null +++ b/internal/distributed/proxyservice/client.go @@ -0,0 +1,52 @@ +package grpcproxyservice + +import ( + "context" + + "google.golang.org/grpc" + + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" +) + +type Client struct { + proxyServiceClient proxypb.ProxyServiceClient + address string + ctx context.Context +} + +func (c *Client) tryConnect() error { + if c.proxyServiceClient != nil { + return nil + } + conn, err := grpc.DialContext(c.ctx, c.address, grpc.WithInsecure(), grpc.WithBlock()) + if err != nil { + return err + } + c.proxyServiceClient = proxypb.NewProxyServiceClient(conn) + return nil +} + +func (c *Client) RegisterNode(request *proxypb.RegisterNodeRequest) (*proxypb.RegisterNodeResponse, error) { + err := c.tryConnect() + if err != nil { + return nil, err + } + return c.proxyServiceClient.RegisterNode(c.ctx, request) +} + +func (c *Client) InvalidateCollectionMetaCache(request *proxypb.InvalidateCollMetaCacheRequest) error { + var err error + err = c.tryConnect() + if err != nil { + return err + } + _, err = c.proxyServiceClient.InvalidateCollectionMetaCache(c.ctx, request) + return err +} + +func NewClient(ctx context.Context, address string) *Client { + return &Client{ + address: address, + ctx: ctx, + } +} diff --git a/internal/distributed/proxyservice/paramtable.go b/internal/distributed/proxyservice/paramtable.go new file mode 100644 index 0000000000..63fdf1ded7 --- /dev/null +++ b/internal/distributed/proxyservice/paramtable.go @@ -0,0 +1,46 @@ +package grpcproxyservice + +import ( + "net" + "strconv" + + "github.com/zilliztech/milvus-distributed/internal/util/paramtable" +) + +type ParamTable struct { + paramtable.BaseTable +} + +var Params ParamTable + +func (pt *ParamTable) Init() { + pt.BaseTable.Init() +} + +func (pt *ParamTable) NetworkPort() int { + return pt.ParseInt("proxyService.port") +} + +func (pt *ParamTable) NetworkAddress() string { + addr, err := pt.Load("proxyService.address") + if err != nil { + panic(err) + } + + hostName, _ := net.LookupHost(addr) + if len(hostName) <= 0 { + if ip := net.ParseIP(addr); ip == nil { + panic("invalid ip proxyService.address") + } + } + + port, err := pt.Load("proxyService.port") + if err != nil { + panic(err) + } + _, err = strconv.Atoi(port) + if err != nil { + panic(err) + } + return addr + ":" + port +} diff --git a/internal/distributed/proxyservice/service.go b/internal/distributed/proxyservice/service.go new file mode 100644 index 0000000000..304275ccdd --- /dev/null +++ b/internal/distributed/proxyservice/service.go @@ -0,0 +1,84 @@ +package grpcproxyservice + +import ( + "context" + "fmt" + "net" + "strconv" + "sync" + + "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" + + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" + + "github.com/zilliztech/milvus-distributed/internal/proxyservice" + "google.golang.org/grpc" +) + +type Server struct { + ctx context.Context + wg sync.WaitGroup + impl proxyservice.ProxyService + grpcServer *grpc.Server +} + +func CreateProxyServiceServer() (*Server, error) { + return &Server{}, nil +} + +func (s *Server) Init() error { + s.ctx = context.Background() + Params.Init() + s.impl, _ = proxyservice.CreateProxyService(s.ctx) + s.impl.Init() + return nil +} + +func (s *Server) Start() error { + fmt.Println("proxy service start ...") + s.wg.Add(1) + go func() { + defer s.wg.Done() + + // TODO: use config + fmt.Println("network port: ", Params.NetworkPort()) + lis, err := net.Listen("tcp", ":"+strconv.Itoa(Params.NetworkPort())) + if err != nil { + panic(err) + } + + s.grpcServer = grpc.NewServer() + proxypb.RegisterProxyServiceServer(s.grpcServer, s) + milvuspb.RegisterProxyServiceServer(s.grpcServer, s) + if err = s.grpcServer.Serve(lis); err != nil { + panic(err) + } + }() + + s.impl.Start() + + return nil +} + +func (s *Server) Stop() error { + s.impl.Stop() + if s.grpcServer != nil { + s.grpcServer.GracefulStop() + } + s.wg.Wait() + return nil +} + +func (s *Server) RegisterLink(ctx context.Context, empty *commonpb.Empty) (*milvuspb.RegisterLinkResponse, error) { + return s.impl.RegisterLink() +} + +func (s *Server) RegisterNode(ctx context.Context, request *proxypb.RegisterNodeRequest) (*proxypb.RegisterNodeResponse, error) { + return s.impl.RegisterNode(request) +} + +func (s *Server) InvalidateCollectionMetaCache(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) { + return &commonpb.Status{}, s.impl.InvalidateCollectionMetaCache(request) +} diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto index 779f7508ea..3373baf78d 100644 --- a/internal/proto/milvus.proto +++ b/internal/proto/milvus.proto @@ -292,3 +292,12 @@ service MilvusService { rpc GetDdChannel(common.Empty) returns (StringResponse) {} } + +message RegisterLinkResponse { + common.Address address = 1; + common.Status status = 2; +} + +service ProxyService { + rpc RegisterLink(common.Empty) returns (RegisterLinkResponse) {} +} diff --git a/internal/proto/milvuspb/milvus.pb.go b/internal/proto/milvuspb/milvus.pb.go index 75ef8422fc..b790e9c1e4 100644 --- a/internal/proto/milvuspb/milvus.pb.go +++ b/internal/proto/milvuspb/milvus.pb.go @@ -2297,6 +2297,53 @@ func (m *FlushRequest) GetCollectionName() string { return "" } +type RegisterLinkResponse struct { + Address *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} } +func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) } +func (*RegisterLinkResponse) ProtoMessage() {} +func (*RegisterLinkResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_02345ba45cc0e303, []int{40} +} + +func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RegisterLinkResponse.Unmarshal(m, b) +} +func (m *RegisterLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RegisterLinkResponse.Marshal(b, m, deterministic) +} +func (m *RegisterLinkResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegisterLinkResponse.Merge(m, src) +} +func (m *RegisterLinkResponse) XXX_Size() int { + return xxx_messageInfo_RegisterLinkResponse.Size(m) +} +func (m *RegisterLinkResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RegisterLinkResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RegisterLinkResponse proto.InternalMessageInfo + +func (m *RegisterLinkResponse) GetAddress() *commonpb.Address { + if m != nil { + return m.Address + } + return nil +} + +func (m *RegisterLinkResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + func init() { proto.RegisterEnum("milvus.proto.milvus.PlaceholderType", PlaceholderType_name, PlaceholderType_value) proto.RegisterType((*CreateCollectionRequest)(nil), "milvus.proto.milvus.CreateCollectionRequest") @@ -2339,112 +2386,117 @@ func init() { proto.RegisterType((*Hits)(nil), "milvus.proto.milvus.Hits") proto.RegisterType((*SearchResults)(nil), "milvus.proto.milvus.SearchResults") proto.RegisterType((*FlushRequest)(nil), "milvus.proto.milvus.FlushRequest") + proto.RegisterType((*RegisterLinkResponse)(nil), "milvus.proto.milvus.RegisterLinkResponse") } func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) } var fileDescriptor_02345ba45cc0e303 = []byte{ - // 1591 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6e, 0x1b, 0x45, - 0x14, 0xce, 0xc6, 0x8e, 0x9b, 0x9c, 0xd8, 0x8e, 0x33, 0xf9, 0x73, 0xdd, 0x96, 0xa6, 0x03, 0x25, - 0xe9, 0x5f, 0x82, 0x52, 0x10, 0x70, 0x81, 0xd4, 0x26, 0x4e, 0x53, 0xab, 0x6d, 0x1a, 0xd6, 0xa1, - 0x22, 0x54, 0x95, 0x59, 0x7b, 0x87, 0x78, 0x61, 0xbd, 0x6b, 0x76, 0xc6, 0x49, 0xd3, 0x2b, 0x04, - 0x12, 0x48, 0x80, 0x80, 0x5b, 0x6e, 0x91, 0xb8, 0x45, 0x50, 0x24, 0xde, 0x00, 0x89, 0x77, 0x41, - 0x88, 0x27, 0x40, 0x42, 0x3b, 0xb3, 0x59, 0xef, 0x6e, 0x66, 0x63, 0x53, 0x03, 0x76, 0xee, 0x76, - 0x8e, 0xcf, 0x9c, 0xf9, 0xce, 0xcf, 0xcc, 0x9c, 0xf9, 0x0c, 0xe9, 0x86, 0x61, 0xee, 0xb5, 0xe8, - 0x52, 0xd3, 0xb1, 0x99, 0x8d, 0xa6, 0x82, 0xa3, 0x25, 0x31, 0x28, 0xa4, 0x6b, 0x76, 0xa3, 0x61, - 0x5b, 0x42, 0x58, 0x48, 0xd3, 0x5a, 0x9d, 0x34, 0x34, 0x31, 0xc2, 0xdf, 0x2b, 0x30, 0xb7, 0xe6, - 0x10, 0x8d, 0x91, 0x35, 0xdb, 0x34, 0x49, 0x8d, 0x19, 0xb6, 0xa5, 0x92, 0x0f, 0x5b, 0x84, 0x32, - 0xf4, 0x12, 0x24, 0xab, 0x1a, 0x25, 0x79, 0x65, 0x5e, 0x59, 0x1c, 0x5f, 0x39, 0xbb, 0x14, 0xb2, - 0xed, 0xd9, 0xbc, 0x47, 0x77, 0x57, 0x35, 0x4a, 0x54, 0xae, 0x89, 0xe6, 0xe0, 0x94, 0x5e, 0xad, - 0x58, 0x5a, 0x83, 0xe4, 0x87, 0xe7, 0x95, 0xc5, 0x31, 0x35, 0xa5, 0x57, 0x37, 0xb5, 0x06, 0x41, - 0x0b, 0x30, 0x51, 0xf3, 0xed, 0x0b, 0x85, 0x04, 0x57, 0xc8, 0xb6, 0xc5, 0x5c, 0x71, 0x16, 0x52, - 0x02, 0x5f, 0x3e, 0x39, 0xaf, 0x2c, 0xa6, 0x55, 0x6f, 0x84, 0xbf, 0x50, 0x60, 0xa6, 0xe8, 0xd8, - 0xcd, 0x81, 0x40, 0x89, 0x3f, 0x57, 0x60, 0xfa, 0xb6, 0x46, 0x07, 0x03, 0xcc, 0x0e, 0xa4, 0x57, - 0x6d, 0xdb, 0x54, 0x09, 0x6d, 0xda, 0x16, 0x25, 0xe8, 0x3a, 0xa4, 0x28, 0xd3, 0x58, 0x8b, 0x7a, - 0x28, 0xce, 0x48, 0x51, 0x94, 0xb9, 0x8a, 0xea, 0xa9, 0xa2, 0x69, 0x18, 0xd9, 0xd3, 0xcc, 0x96, - 0x00, 0x31, 0xaa, 0x8a, 0x01, 0x7e, 0x08, 0xd9, 0x32, 0x73, 0x0c, 0x6b, 0xf7, 0x5f, 0x34, 0x3e, - 0x76, 0x68, 0xfc, 0x6b, 0x05, 0x4e, 0x17, 0x09, 0xad, 0x39, 0x46, 0x75, 0x30, 0x8a, 0x0f, 0x7f, - 0xa3, 0x40, 0x41, 0x86, 0xa8, 0x17, 0xdf, 0xdf, 0xf0, 0x0b, 0x7a, 0x98, 0x4f, 0xba, 0x18, 0x9e, - 0xe4, 0x6d, 0xc6, 0xf6, 0x6a, 0x65, 0x2e, 0x08, 0xd5, 0xfd, 0x5d, 0x5b, 0xd3, 0x07, 0x23, 0x40, - 0x5f, 0x29, 0x90, 0x57, 0x89, 0x49, 0x34, 0x3a, 0x20, 0x19, 0xfb, 0x52, 0x81, 0xd9, 0x40, 0xec, - 0x98, 0xc6, 0x68, 0x3f, 0xe1, 0x7c, 0xe6, 0x9e, 0xa6, 0x51, 0x38, 0xbd, 0x54, 0xcf, 0xab, 0x30, - 0xe2, 0x7e, 0xd1, 0xfc, 0xf0, 0x7c, 0x62, 0x71, 0x7c, 0xe5, 0x82, 0x74, 0xce, 0x1d, 0x72, 0xf0, - 0xc0, 0xdd, 0x51, 0x5b, 0x9a, 0xe1, 0xa8, 0x42, 0x1f, 0x57, 0x61, 0xa6, 0x5c, 0xb7, 0xf7, 0xff, - 0xcb, 0x2c, 0xe1, 0xc7, 0x30, 0x1b, 0x5d, 0xa3, 0x17, 0x5f, 0x2f, 0x41, 0x2e, 0x12, 0x65, 0xe1, - 0xf6, 0x98, 0x3a, 0x11, 0x0e, 0x33, 0xc5, 0x3f, 0xbb, 0x69, 0xe7, 0xb7, 0xd6, 0x96, 0xe6, 0x30, - 0xa3, 0xdf, 0x97, 0xd6, 0x45, 0xc8, 0x36, 0x0f, 0x71, 0x08, 0xbd, 0x24, 0xd7, 0xcb, 0xf8, 0x52, - 0x1e, 0xaf, 0x9f, 0x14, 0x98, 0x76, 0xef, 0xb0, 0x93, 0x84, 0xf9, 0x47, 0x05, 0xa6, 0x6e, 0x6b, - 0xf4, 0x24, 0x41, 0x7e, 0xaa, 0xc0, 0x94, 0x7b, 0x64, 0x0a, 0xcc, 0xfd, 0x85, 0xbc, 0x00, 0x13, - 0x61, 0xc8, 0x34, 0x9f, 0xe4, 0x25, 0x9d, 0x0d, 0x61, 0xa6, 0xf8, 0x17, 0x05, 0xe6, 0xbc, 0x93, - 0x75, 0x20, 0x62, 0xdd, 0x35, 0xf0, 0xa7, 0x0a, 0xcc, 0xf8, 0x88, 0xfb, 0x7d, 0x00, 0x77, 0x5b, - 0x22, 0x9f, 0x2a, 0x30, 0x1b, 0x05, 0xdd, 0x97, 0x63, 0xfa, 0x07, 0x05, 0xa6, 0xdd, 0x33, 0x74, - 0x20, 0x72, 0x8e, 0x21, 0xdd, 0x96, 0x94, 0x8a, 0x3c, 0x74, 0x09, 0x35, 0x24, 0xc3, 0xdf, 0x2a, - 0xe2, 0x62, 0x09, 0x00, 0xee, 0x25, 0x70, 0x92, 0x32, 0x1b, 0x96, 0x95, 0x99, 0x8b, 0xcd, 0x97, - 0x94, 0x8a, 0x34, 0x9f, 0x98, 0x4f, 0xb8, 0xd8, 0x82, 0x32, 0xde, 0x0c, 0x1c, 0xb6, 0x6f, 0x65, - 0xb2, 0xdb, 0x20, 0x16, 0x7b, 0xf6, 0x70, 0x46, 0x83, 0x31, 0x7c, 0x34, 0x18, 0xe8, 0x2c, 0x8c, - 0x51, 0xb1, 0x4e, 0xa9, 0xc8, 0x63, 0x9a, 0x50, 0xdb, 0x02, 0x5c, 0x87, 0xb9, 0x23, 0x68, 0x7a, - 0x89, 0x55, 0x1e, 0x4e, 0x19, 0x96, 0x4e, 0x1e, 0xfb, 0x60, 0x0e, 0x87, 0xae, 0xe3, 0xc8, 0x4d, - 0xca, 0xff, 0xe2, 0xf4, 0x3c, 0x8c, 0x07, 0xa2, 0xee, 0xb9, 0x1d, 0x14, 0xe1, 0xf7, 0x61, 0x2a, - 0x84, 0xa6, 0x17, 0xa7, 0x9f, 0x03, 0xf0, 0x23, 0x2a, 0x6a, 0x23, 0xa1, 0x06, 0x24, 0xf8, 0x0f, - 0x05, 0x90, 0xe8, 0x04, 0x4a, 0x6e, 0x30, 0xfa, 0xb9, 0x7d, 0xce, 0x01, 0xbc, 0x67, 0x10, 0x53, - 0x0f, 0x9e, 0x3b, 0x63, 0x5c, 0xc2, 0x7f, 0x2e, 0x42, 0x9a, 0x3c, 0x66, 0x8e, 0x56, 0x69, 0x6a, - 0x8e, 0xd6, 0xa0, 0xf9, 0x91, 0x6e, 0x8f, 0x8a, 0x71, 0x3e, 0x6d, 0x8b, 0xcf, 0xc2, 0xbf, 0xb9, - 0x3d, 0x84, 0x57, 0x55, 0x83, 0xee, 0xf1, 0x39, 0x00, 0x5e, 0xa1, 0xe2, 0xe7, 0x11, 0xf1, 0x33, - 0x97, 0xf0, 0x43, 0xd8, 0x84, 0x1c, 0xf7, 0x40, 0xb8, 0xd3, 0x74, 0xad, 0x46, 0xa6, 0x28, 0x91, - 0x29, 0xe8, 0x75, 0x48, 0x79, 0xd1, 0xeb, 0xfa, 0xa0, 0xf5, 0x26, 0xe0, 0xef, 0x14, 0x98, 0x89, - 0x04, 0xae, 0x97, 0xba, 0xdc, 0x06, 0x24, 0x80, 0xea, 0x6d, 0xf4, 0x87, 0xa8, 0x22, 0x4f, 0x3c, - 0x6f, 0x10, 0xf5, 0x55, 0x9d, 0x34, 0x22, 0x12, 0x8a, 0x7f, 0x55, 0x60, 0x92, 0xeb, 0xb9, 0xab, - 0x91, 0x93, 0x9b, 0xda, 0x8f, 0x14, 0x40, 0x41, 0x3f, 0x7a, 0x89, 0xf4, 0x2b, 0xe2, 0x6e, 0x15, - 0x9e, 0x64, 0x57, 0xce, 0x4b, 0xe7, 0x04, 0x16, 0x13, 0xda, 0xf8, 0x2f, 0x05, 0x32, 0x25, 0x8b, - 0x12, 0x87, 0x0d, 0x7e, 0x3f, 0x82, 0x5e, 0x86, 0x51, 0xc7, 0xde, 0xaf, 0xe8, 0x1a, 0xd3, 0xbc, - 0x73, 0xe1, 0xb4, 0x14, 0xde, 0xaa, 0x69, 0x57, 0xd5, 0x53, 0x8e, 0xbd, 0x5f, 0xd4, 0x98, 0x86, - 0xce, 0xc0, 0x58, 0x5d, 0xa3, 0xf5, 0xca, 0x07, 0xe4, 0x80, 0xe6, 0x53, 0xf3, 0x89, 0xc5, 0x8c, - 0x3a, 0xea, 0x0a, 0xee, 0x90, 0x03, 0x8a, 0x3f, 0x51, 0x20, 0x7b, 0xe8, 0x7f, 0x2f, 0xe1, 0x3f, - 0x0f, 0xe3, 0x8e, 0xbd, 0x5f, 0x2a, 0x56, 0xaa, 0x64, 0xd7, 0xb0, 0xbc, 0x1b, 0x01, 0xb8, 0x68, - 0xd5, 0x95, 0xb8, 0x28, 0x84, 0x02, 0xb1, 0x74, 0xef, 0x36, 0x18, 0xe5, 0x82, 0x75, 0x4b, 0xc7, - 0x7b, 0x90, 0xdb, 0x32, 0xb5, 0x1a, 0xa9, 0xdb, 0xa6, 0x4e, 0x1c, 0xbe, 0x2b, 0x51, 0x0e, 0x12, - 0x4c, 0xdb, 0xf5, 0x36, 0xb7, 0xfb, 0x89, 0x5e, 0x83, 0x24, 0x3b, 0x68, 0x1e, 0x66, 0xf8, 0x05, - 0xe9, 0xf6, 0x09, 0x98, 0xd9, 0x3e, 0x68, 0x12, 0x95, 0xcf, 0x40, 0xb3, 0x90, 0xe2, 0x64, 0x92, - 0x68, 0x08, 0xd2, 0xaa, 0x37, 0xc2, 0x8f, 0x42, 0xeb, 0x6e, 0x38, 0x76, 0xab, 0x89, 0x4a, 0x90, - 0x6e, 0xb6, 0x65, 0x6e, 0x10, 0xe2, 0x37, 0x6b, 0x14, 0xb4, 0x1a, 0x9a, 0x8a, 0x7f, 0x57, 0x20, - 0x53, 0x26, 0x9a, 0x53, 0xab, 0x9f, 0x84, 0x1e, 0xdd, 0x8d, 0xb8, 0x4e, 0x4d, 0x6f, 0x9b, 0xba, - 0x9f, 0xe8, 0x0a, 0x4c, 0x06, 0x1c, 0xaa, 0xec, 0xba, 0x01, 0xca, 0xa7, 0x38, 0xe3, 0x9a, 0x6b, - 0x46, 0x02, 0x87, 0xef, 0x40, 0xf2, 0xb6, 0xc1, 0xb8, 0x19, 0xf7, 0x12, 0x56, 0xf8, 0x25, 0xec, - 0x7e, 0xa2, 0xd3, 0x81, 0xba, 0x1d, 0xe6, 0x09, 0xf0, 0x8b, 0x93, 0x13, 0xb9, 0xb6, 0xe3, 0x65, - 0x66, 0x58, 0xf5, 0x46, 0xf8, 0xed, 0x76, 0xe4, 0x68, 0xcb, 0x64, 0xf4, 0xd9, 0xaa, 0x12, 0x41, - 0xb2, 0x6e, 0x78, 0xfd, 0x76, 0x5a, 0xe5, 0xdf, 0xf8, 0x63, 0x05, 0xd2, 0xb7, 0xcc, 0x16, 0xed, - 0x67, 0x4e, 0x2e, 0xdf, 0x80, 0x89, 0x48, 0xa5, 0xa2, 0x51, 0x48, 0x6e, 0xde, 0xdf, 0x5c, 0xcf, - 0x0d, 0xa1, 0x49, 0xc8, 0x3c, 0x58, 0x5f, 0xdb, 0xbe, 0xaf, 0x56, 0x56, 0x4b, 0x9b, 0x37, 0xd5, - 0x9d, 0x9c, 0x8e, 0x72, 0x90, 0xf6, 0x44, 0xb7, 0xee, 0xde, 0xbf, 0xb9, 0x9d, 0x23, 0x2b, 0x7f, - 0xe6, 0x20, 0x73, 0x8f, 0x23, 0x2d, 0x13, 0x67, 0xcf, 0xa8, 0x11, 0x54, 0x81, 0x5c, 0x94, 0xa2, - 0x47, 0x57, 0xa5, 0x65, 0x1b, 0xc3, 0xe4, 0x17, 0x8e, 0x8b, 0x29, 0x1e, 0x42, 0x0f, 0x21, 0x1b, - 0xe6, 0xd6, 0xd1, 0x65, 0xa9, 0x79, 0x29, 0x01, 0xdf, 0xc9, 0x78, 0x05, 0x32, 0x21, 0xaa, 0x1c, - 0x5d, 0x92, 0xda, 0x96, 0xd1, 0xe9, 0x85, 0x0b, 0x52, 0xd5, 0x20, 0xdb, 0x2d, 0xd0, 0x87, 0x19, - 0xd2, 0x18, 0xf4, 0x52, 0x1a, 0xb5, 0x13, 0x7a, 0x0d, 0x26, 0x8f, 0x10, 0x9e, 0xe8, 0x9a, 0xd4, - 0x7e, 0x1c, 0x31, 0xda, 0x69, 0x89, 0x7d, 0x40, 0x47, 0x49, 0x67, 0xb4, 0x24, 0xcf, 0x40, 0x1c, - 0x5f, 0x5e, 0x58, 0xee, 0x5a, 0xdf, 0x0f, 0xdc, 0x1e, 0xcc, 0x6d, 0x10, 0x16, 0xe6, 0x2b, 0x0d, - 0xca, 0x8c, 0x1a, 0x45, 0x57, 0xe4, 0xe5, 0x25, 0x65, 0x5a, 0x0b, 0x57, 0xbb, 0x53, 0xf6, 0xd7, - 0x35, 0x61, 0x22, 0xcc, 0x1b, 0xd2, 0x98, 0x8c, 0x49, 0x19, 0xcc, 0xc2, 0x95, 0xae, 0x74, 0xfd, - 0xd5, 0x1e, 0xc1, 0x44, 0x84, 0x2a, 0x8c, 0xf3, 0x4e, 0x4a, 0x28, 0x76, 0xca, 0xde, 0x0e, 0x64, - 0x42, 0x9c, 0x5e, 0x4c, 0x79, 0xcb, 0x78, 0xbf, 0x4e, 0xa6, 0x1f, 0x41, 0x3a, 0x48, 0xbd, 0xa1, - 0xc5, 0xb8, 0x8d, 0x73, 0xc4, 0x70, 0x57, 0xfb, 0x66, 0x47, 0xec, 0x1b, 0x7f, 0x32, 0x8d, 0x59, - 0x40, 0xc2, 0xa5, 0x75, 0x42, 0xfe, 0xae, 0xbf, 0x6b, 0x02, 0xd6, 0xaf, 0x1e, 0xb7, 0x6b, 0xfe, - 0x69, 0x6c, 0x28, 0xcc, 0x6e, 0x10, 0x16, 0xe2, 0x70, 0xbc, 0xd2, 0x95, 0x97, 0x92, 0x94, 0xa2, - 0x8a, 0x29, 0x25, 0x39, 0x33, 0x84, 0x87, 0x90, 0x01, 0xd9, 0x10, 0xf7, 0x41, 0x63, 0x92, 0x2d, - 0x63, 0x74, 0x0a, 0x97, 0xbb, 0x51, 0xf5, 0x97, 0x7a, 0x0b, 0xc6, 0x03, 0xcf, 0x5a, 0xb4, 0x70, - 0x4c, 0xc5, 0x06, 0x9f, 0x81, 0x9d, 0xc2, 0x56, 0x87, 0x4c, 0xe8, 0x11, 0x14, 0x57, 0xad, 0x92, - 0x17, 0x66, 0x8c, 0x03, 0xd2, 0x37, 0x15, 0x1e, 0x42, 0x55, 0xc8, 0x6c, 0x10, 0xd6, 0xee, 0xcb, - 0xd1, 0x8b, 0xf1, 0xaf, 0xa2, 0xe0, 0x6b, 0xa7, 0xb0, 0xd0, 0x51, 0xcf, 0x5f, 0xa3, 0x0c, 0x29, - 0xd1, 0xe2, 0x22, 0x1c, 0x33, 0x29, 0xd0, 0xff, 0x17, 0x9e, 0x3f, 0x56, 0xc7, 0x37, 0xaa, 0x42, - 0x4a, 0x34, 0x28, 0x31, 0x46, 0x43, 0x7d, 0x5f, 0xe1, 0x78, 0x1d, 0xde, 0xe1, 0xe0, 0x21, 0x54, - 0x82, 0x11, 0xde, 0x99, 0x20, 0xf9, 0xc6, 0x0c, 0x76, 0x2d, 0x9d, 0x32, 0xf8, 0x26, 0xa4, 0x37, - 0x08, 0x2b, 0xea, 0x6b, 0x75, 0xcd, 0xb2, 0x88, 0x89, 0x0a, 0x52, 0xf5, 0xf5, 0x46, 0x93, 0x1d, - 0xc4, 0x78, 0x1c, 0xfe, 0x47, 0x17, 0x0f, 0xad, 0xae, 0xbe, 0x73, 0x63, 0xd7, 0x60, 0xf5, 0x56, - 0xd5, 0x9d, 0xbd, 0xfc, 0xc4, 0x30, 0x4d, 0xe3, 0x09, 0x23, 0xb5, 0xfa, 0xb2, 0x98, 0x70, 0x4d, - 0x37, 0x28, 0x73, 0x8c, 0x6a, 0x8b, 0x11, 0x7d, 0xd9, 0xb0, 0x18, 0x71, 0x2c, 0xcd, 0x5c, 0xe6, - 0x26, 0x3d, 0x8d, 0x66, 0xb5, 0x9a, 0xe2, 0xe3, 0xeb, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xf7, - 0x29, 0xea, 0x7b, 0x8f, 0x20, 0x00, 0x00, + // 1661 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0x1b, 0xc5, + 0x16, 0xcf, 0xda, 0x8e, 0x93, 0x9c, 0xac, 0x1d, 0x67, 0xf2, 0xe5, 0xba, 0xed, 0x6d, 0x3a, 0xf7, + 0xf6, 0x26, 0xfd, 0x4a, 0xae, 0xd2, 0xfb, 0xf9, 0x70, 0xa5, 0x36, 0x71, 0x9a, 0x5a, 0x6d, 0xd3, + 0xdc, 0x75, 0x6e, 0x21, 0x54, 0x95, 0x59, 0x7b, 0x07, 0x7b, 0xe9, 0x7a, 0xd7, 0xec, 0x8c, 0xf3, + 0xd1, 0x27, 0x04, 0x12, 0x48, 0x80, 0x80, 0x57, 0x5e, 0x91, 0x78, 0x45, 0x50, 0x24, 0xfe, 0x03, + 0x24, 0xfe, 0x17, 0x84, 0xf8, 0x0b, 0x90, 0xd0, 0xce, 0xae, 0xd7, 0xbb, 0x9b, 0xd9, 0xd8, 0xd4, + 0x40, 0x9c, 0xb7, 0x9d, 0xe3, 0x33, 0x67, 0x7e, 0xe7, 0x37, 0xe7, 0xcc, 0x9c, 0x39, 0x06, 0xb9, + 0xa9, 0x1b, 0xfb, 0x6d, 0xba, 0xd2, 0xb2, 0x2d, 0x66, 0xa1, 0x99, 0xe0, 0x68, 0xc5, 0x1d, 0x14, + 0xe4, 0x9a, 0xd5, 0x6c, 0x5a, 0xa6, 0x2b, 0x2c, 0xc8, 0xb4, 0xd6, 0x20, 0x4d, 0xd5, 0x1d, 0xe1, + 0x2f, 0x24, 0x58, 0xd8, 0xb0, 0x89, 0xca, 0xc8, 0x86, 0x65, 0x18, 0xa4, 0xc6, 0x74, 0xcb, 0x54, + 0xc8, 0x5b, 0x6d, 0x42, 0x19, 0xfa, 0x1b, 0xa4, 0xaa, 0x2a, 0x25, 0x79, 0x69, 0x51, 0x5a, 0x9e, + 0x5c, 0xbb, 0xb0, 0x12, 0xb2, 0xed, 0xd9, 0x7c, 0x48, 0xeb, 0xeb, 0x2a, 0x25, 0x0a, 0xd7, 0x44, + 0x0b, 0x30, 0xa6, 0x55, 0x2b, 0xa6, 0xda, 0x24, 0xf9, 0xc4, 0xa2, 0xb4, 0x3c, 0xa1, 0xa4, 0xb5, + 0xea, 0xb6, 0xda, 0x24, 0x68, 0x09, 0xa6, 0x6a, 0xbe, 0x7d, 0x57, 0x21, 0xc9, 0x15, 0xb2, 0x5d, + 0x31, 0x57, 0x9c, 0x87, 0xb4, 0x8b, 0x2f, 0x9f, 0x5a, 0x94, 0x96, 0x65, 0xc5, 0x1b, 0xe1, 0x0f, + 0x25, 0x98, 0x2b, 0xda, 0x56, 0x6b, 0x28, 0x50, 0xe2, 0x0f, 0x24, 0x98, 0xbd, 0xa7, 0xd2, 0xe1, + 0x00, 0xb3, 0x07, 0xf2, 0xba, 0x65, 0x19, 0x0a, 0xa1, 0x2d, 0xcb, 0xa4, 0x04, 0xdd, 0x82, 0x34, + 0x65, 0x2a, 0x6b, 0x53, 0x0f, 0xc5, 0x79, 0x21, 0x8a, 0x32, 0x57, 0x51, 0x3c, 0x55, 0x34, 0x0b, + 0xa3, 0xfb, 0xaa, 0xd1, 0x76, 0x41, 0x8c, 0x2b, 0xee, 0x00, 0x3f, 0x81, 0x6c, 0x99, 0xd9, 0xba, + 0x59, 0xff, 0x0d, 0x8d, 0x4f, 0x74, 0x8c, 0x7f, 0x22, 0xc1, 0xb9, 0x22, 0xa1, 0x35, 0x5b, 0xaf, + 0x0e, 0x47, 0xf0, 0xe1, 0x4f, 0x25, 0x28, 0x88, 0x10, 0x0d, 0xe2, 0xfb, 0x7f, 0xfd, 0x80, 0x4e, + 0xf0, 0x49, 0x57, 0xc2, 0x93, 0xbc, 0x64, 0xec, 0xae, 0x56, 0xe6, 0x82, 0x50, 0xdc, 0x3f, 0xb0, + 0x54, 0x6d, 0x38, 0x08, 0xfa, 0x58, 0x82, 0xbc, 0x42, 0x0c, 0xa2, 0xd2, 0x21, 0xd9, 0xb1, 0x8f, + 0x24, 0x98, 0x0f, 0x70, 0xc7, 0x54, 0x46, 0x4f, 0x13, 0xce, 0xfb, 0xce, 0x69, 0x1a, 0x85, 0x33, + 0x48, 0xf4, 0xfc, 0x0b, 0x46, 0x9d, 0x2f, 0x9a, 0x4f, 0x2c, 0x26, 0x97, 0x27, 0xd7, 0x2e, 0x0b, + 0xe7, 0xdc, 0x27, 0x47, 0x8f, 0x9d, 0x8c, 0xda, 0x51, 0x75, 0x5b, 0x71, 0xf5, 0x71, 0x15, 0xe6, + 0xca, 0x0d, 0xeb, 0xe0, 0xf7, 0xdc, 0x25, 0x7c, 0x08, 0xf3, 0xd1, 0x35, 0x06, 0xf1, 0xf5, 0x2a, + 0xe4, 0x22, 0x2c, 0xbb, 0x6e, 0x4f, 0x28, 0x53, 0x61, 0x9a, 0x29, 0xfe, 0xc6, 0xd9, 0x76, 0x7e, + 0x6b, 0xed, 0xa8, 0x36, 0xd3, 0x4f, 0xfb, 0xd2, 0xba, 0x02, 0xd9, 0x56, 0x07, 0x87, 0xab, 0x97, + 0xe2, 0x7a, 0x19, 0x5f, 0xca, 0xf9, 0xfa, 0x5a, 0x82, 0x59, 0xe7, 0x0e, 0x3b, 0x4b, 0x98, 0xbf, + 0x92, 0x60, 0xe6, 0x9e, 0x4a, 0xcf, 0x12, 0xe4, 0x17, 0x12, 0xcc, 0x38, 0x47, 0xa6, 0x8b, 0xf9, + 0x74, 0x21, 0x2f, 0xc1, 0x54, 0x18, 0x32, 0xcd, 0xa7, 0x78, 0x48, 0x67, 0x43, 0x98, 0x29, 0xfe, + 0x56, 0x82, 0x05, 0xef, 0x64, 0x1d, 0x0a, 0xae, 0xfb, 0x06, 0xfe, 0x42, 0x82, 0x39, 0x1f, 0xf1, + 0x69, 0x1f, 0xc0, 0xfd, 0x86, 0xc8, 0x7b, 0x12, 0xcc, 0x47, 0x41, 0x9f, 0xca, 0x31, 0xfd, 0xa5, + 0x04, 0xb3, 0xce, 0x19, 0x3a, 0x14, 0x7b, 0x8e, 0x41, 0xee, 0x4a, 0x4a, 0x45, 0x4e, 0x5d, 0x52, + 0x09, 0xc9, 0xf0, 0x67, 0x92, 0x7b, 0xb1, 0x04, 0x00, 0x0f, 0x42, 0x9c, 0x20, 0xcc, 0x12, 0xa2, + 0x30, 0x73, 0xb0, 0xf9, 0x92, 0x52, 0x91, 0xe6, 0x93, 0x8b, 0x49, 0x07, 0x5b, 0x50, 0xc6, 0x8b, + 0x81, 0x4e, 0xf9, 0x56, 0x26, 0xf5, 0x26, 0x31, 0xd9, 0xcb, 0xd3, 0x19, 0x25, 0x23, 0x71, 0x9c, + 0x0c, 0x74, 0x01, 0x26, 0xa8, 0xbb, 0x4e, 0xa9, 0xc8, 0x39, 0x4d, 0x2a, 0x5d, 0x01, 0x6e, 0xc0, + 0xc2, 0x31, 0x34, 0x83, 0x70, 0x95, 0x87, 0x31, 0xdd, 0xd4, 0xc8, 0xa1, 0x0f, 0xa6, 0x33, 0x74, + 0x1c, 0x47, 0xce, 0xa6, 0xfc, 0x21, 0x4e, 0x2f, 0xc2, 0x64, 0x80, 0x75, 0xcf, 0xed, 0xa0, 0x08, + 0xbf, 0x09, 0x33, 0x21, 0x34, 0x83, 0x38, 0xfd, 0x27, 0x00, 0x9f, 0x51, 0x37, 0x36, 0x92, 0x4a, + 0x40, 0x82, 0x7f, 0x94, 0x00, 0xb9, 0x95, 0x40, 0xc9, 0x21, 0xe3, 0x34, 0xd3, 0xe7, 0x22, 0xc0, + 0x1b, 0x3a, 0x31, 0xb4, 0xe0, 0xb9, 0x33, 0xc1, 0x25, 0xfc, 0xe7, 0x22, 0xc8, 0xe4, 0x90, 0xd9, + 0x6a, 0xa5, 0xa5, 0xda, 0x6a, 0x93, 0xe6, 0x47, 0xfb, 0x3d, 0x2a, 0x26, 0xf9, 0xb4, 0x1d, 0x3e, + 0x0b, 0x7f, 0xef, 0xd4, 0x10, 0x5e, 0x54, 0x0d, 0xbb, 0xc7, 0x17, 0x01, 0x78, 0x84, 0xba, 0x3f, + 0x8f, 0xba, 0x3f, 0x73, 0x09, 0x3f, 0x84, 0x0d, 0xc8, 0x71, 0x0f, 0x5c, 0x77, 0x5a, 0x8e, 0xd5, + 0xc8, 0x14, 0x29, 0x32, 0x05, 0xfd, 0x07, 0xd2, 0x1e, 0x7b, 0x7d, 0x1f, 0xb4, 0xde, 0x04, 0xfc, + 0xb9, 0x04, 0x73, 0x11, 0xe2, 0x06, 0x89, 0xcb, 0x5d, 0x40, 0x2e, 0x50, 0xad, 0x8b, 0xbe, 0x83, + 0x2a, 0xf2, 0xc4, 0xf3, 0x06, 0x51, 0x5f, 0x95, 0x69, 0x3d, 0x22, 0xa1, 0xf8, 0x3b, 0x09, 0xa6, + 0xb9, 0x9e, 0xb3, 0x1a, 0x39, 0xbb, 0x5b, 0xfb, 0xb6, 0x04, 0x28, 0xe8, 0xc7, 0x20, 0x4c, 0xff, + 0xc3, 0xbd, 0x5b, 0x5d, 0x4f, 0xb2, 0x6b, 0x97, 0x84, 0x73, 0x02, 0x8b, 0xb9, 0xda, 0xf8, 0x67, + 0x09, 0x32, 0x25, 0x93, 0x12, 0x9b, 0x0d, 0x7f, 0x3d, 0x82, 0xfe, 0x0e, 0xe3, 0xb6, 0x75, 0x50, + 0xd1, 0x54, 0xa6, 0x7a, 0xe7, 0xc2, 0x39, 0x21, 0xbc, 0x75, 0xc3, 0xaa, 0x2a, 0x63, 0xb6, 0x75, + 0x50, 0x54, 0x99, 0x8a, 0xce, 0xc3, 0x44, 0x43, 0xa5, 0x8d, 0xca, 0x33, 0x72, 0x44, 0xf3, 0xe9, + 0xc5, 0xe4, 0x72, 0x46, 0x19, 0x77, 0x04, 0xf7, 0xc9, 0x11, 0xc5, 0xef, 0x4a, 0x90, 0xed, 0xf8, + 0x3f, 0x08, 0xfd, 0x97, 0x60, 0xd2, 0xb6, 0x0e, 0x4a, 0xc5, 0x4a, 0x95, 0xd4, 0x75, 0xd3, 0xbb, + 0x11, 0x80, 0x8b, 0xd6, 0x1d, 0x89, 0x83, 0xc2, 0x55, 0x20, 0xa6, 0xe6, 0xdd, 0x06, 0xe3, 0x5c, + 0xb0, 0x69, 0x6a, 0x78, 0x1f, 0x72, 0x3b, 0x86, 0x5a, 0x23, 0x0d, 0xcb, 0xd0, 0x88, 0xcd, 0xb3, + 0x12, 0xe5, 0x20, 0xc9, 0xd4, 0xba, 0x97, 0xdc, 0xce, 0x27, 0xfa, 0x37, 0xa4, 0xd8, 0x51, 0xab, + 0xb3, 0xc3, 0x7f, 0x11, 0xa6, 0x4f, 0xc0, 0xcc, 0xee, 0x51, 0x8b, 0x28, 0x7c, 0x06, 0x9a, 0x87, + 0x34, 0x6f, 0x26, 0xb9, 0x05, 0x81, 0xac, 0x78, 0x23, 0xfc, 0x34, 0xb4, 0xee, 0x96, 0x6d, 0xb5, + 0x5b, 0xa8, 0x04, 0x72, 0xab, 0x2b, 0x73, 0x48, 0x88, 0x4f, 0xd6, 0x28, 0x68, 0x25, 0x34, 0x15, + 0xff, 0x20, 0x41, 0xa6, 0x4c, 0x54, 0xbb, 0xd6, 0x38, 0x0b, 0x35, 0xba, 0xc3, 0xb8, 0x46, 0x0d, + 0x2f, 0x4d, 0x9d, 0x4f, 0x74, 0x1d, 0xa6, 0x03, 0x0e, 0x55, 0xea, 0x0e, 0x41, 0xf9, 0x34, 0xef, + 0xb8, 0xe6, 0x5a, 0x11, 0xe2, 0xf0, 0x7d, 0x48, 0xdd, 0xd3, 0x19, 0x37, 0xe3, 0x5c, 0xc2, 0x12, + 0xbf, 0x84, 0x9d, 0x4f, 0x74, 0x2e, 0x10, 0xb7, 0x09, 0xbe, 0x01, 0x7e, 0x70, 0xf2, 0x46, 0xae, + 0x65, 0x7b, 0x3b, 0x93, 0x50, 0xbc, 0x11, 0x7e, 0xb5, 0xcb, 0x1c, 0x6d, 0x1b, 0x8c, 0xbe, 0x5c, + 0x54, 0x22, 0x48, 0x35, 0x74, 0xaf, 0xde, 0x96, 0x15, 0xfe, 0x8d, 0xdf, 0x91, 0x40, 0xbe, 0x6b, + 0xb4, 0xe9, 0x69, 0xee, 0x89, 0x93, 0x76, 0xb3, 0x0a, 0xa9, 0xeb, 0x94, 0x11, 0xfb, 0x81, 0x6e, + 0x3e, 0xf3, 0x93, 0xef, 0x9f, 0x30, 0xa6, 0x6a, 0x9a, 0x4d, 0x28, 0x3d, 0x11, 0xcf, 0x1d, 0x57, + 0x47, 0xe9, 0x28, 0x07, 0xe8, 0x49, 0xf4, 0x4d, 0xcf, 0xb5, 0xdb, 0x30, 0x15, 0xc9, 0x17, 0x34, + 0x0e, 0xa9, 0xed, 0x47, 0xdb, 0x9b, 0xb9, 0x11, 0x34, 0x0d, 0x99, 0xc7, 0x9b, 0x1b, 0xbb, 0x8f, + 0x94, 0xca, 0x7a, 0x69, 0xfb, 0x8e, 0xb2, 0x97, 0xd3, 0x50, 0x0e, 0x64, 0x4f, 0x74, 0xf7, 0xc1, + 0xa3, 0x3b, 0xbb, 0x39, 0xb2, 0xf6, 0x53, 0x0e, 0x32, 0x0f, 0xf9, 0x42, 0x65, 0x62, 0xef, 0xeb, + 0x35, 0x82, 0x2a, 0x90, 0x8b, 0xfe, 0x51, 0x80, 0x6e, 0x08, 0x93, 0x27, 0xe6, 0xff, 0x84, 0xc2, + 0x49, 0xd0, 0xf1, 0x08, 0x7a, 0x02, 0xd9, 0x70, 0x87, 0x1f, 0x5d, 0x13, 0x9a, 0x17, 0xfe, 0x0d, + 0xd0, 0xcb, 0x78, 0x05, 0x32, 0xa1, 0x86, 0x3d, 0xba, 0x2a, 0xb4, 0x2d, 0x6a, 0xea, 0x17, 0x2e, + 0x0b, 0x55, 0x83, 0x3d, 0x77, 0x17, 0x7d, 0xb8, 0x4f, 0x1b, 0x83, 0x5e, 0xd8, 0xcc, 0xed, 0x85, + 0x5e, 0x85, 0xe9, 0x63, 0x6d, 0x57, 0x74, 0x53, 0x68, 0x3f, 0xae, 0x3d, 0xdb, 0x6b, 0x89, 0x03, + 0x40, 0xc7, 0x5b, 0xdf, 0x68, 0x45, 0xbc, 0x03, 0x71, 0x5d, 0xfb, 0xc2, 0x6a, 0xdf, 0xfa, 0x3e, + 0x71, 0xfb, 0xb0, 0xb0, 0x45, 0x58, 0xb8, 0x6b, 0xaa, 0x53, 0xa6, 0xd7, 0x28, 0xba, 0x2e, 0x0e, + 0x2f, 0x61, 0xbf, 0xb7, 0x70, 0xa3, 0x3f, 0x65, 0x7f, 0x5d, 0x03, 0xa6, 0xc2, 0xdd, 0x4b, 0x1a, + 0xb3, 0x63, 0xc2, 0x3e, 0x6a, 0xe1, 0x7a, 0x5f, 0xba, 0xfe, 0x6a, 0x4f, 0x61, 0x2a, 0xd2, 0xb0, + 0x8c, 0xf3, 0x4e, 0xd8, 0xd6, 0xec, 0xb5, 0x7b, 0x7b, 0x90, 0x09, 0x75, 0x16, 0x63, 0xc2, 0x5b, + 0xd4, 0x7d, 0xec, 0x65, 0xfa, 0x29, 0xc8, 0xc1, 0x06, 0x20, 0x5a, 0x8e, 0x4b, 0x9c, 0x63, 0x86, + 0xfb, 0xca, 0x9b, 0x3d, 0x37, 0x6f, 0xfc, 0xc9, 0x34, 0x66, 0x01, 0x41, 0x47, 0xaf, 0x17, 0xf2, + 0xd7, 0xfd, 0xac, 0x09, 0x58, 0xbf, 0x71, 0x52, 0xd6, 0xfc, 0x5a, 0x6e, 0x28, 0xcc, 0x6f, 0x11, + 0x16, 0xea, 0x24, 0x79, 0xa1, 0x2b, 0x0e, 0x25, 0x61, 0xa3, 0x2c, 0x26, 0x94, 0xc4, 0xfd, 0x29, + 0x3c, 0x82, 0x74, 0xc8, 0x86, 0x3a, 0x30, 0x34, 0x66, 0xb3, 0x45, 0x7d, 0xa5, 0xc2, 0xb5, 0x7e, + 0x54, 0xfd, 0xa5, 0xfe, 0x0f, 0x93, 0x81, 0xc7, 0x35, 0x5a, 0x3a, 0x21, 0x62, 0x83, 0x8f, 0xd1, + 0x5e, 0xb4, 0x35, 0x20, 0x13, 0x7a, 0x8a, 0xc5, 0x45, 0xab, 0xe0, 0x9d, 0x1b, 0xe3, 0x80, 0xf0, + 0x65, 0x87, 0x47, 0x50, 0x15, 0x32, 0x5b, 0x84, 0x75, 0x5f, 0x07, 0xe8, 0xaf, 0xf1, 0x6f, 0xb3, + 0xe0, 0x9b, 0xab, 0xb0, 0xd4, 0x53, 0xcf, 0x5f, 0xa3, 0x0c, 0x69, 0xb7, 0xd0, 0x46, 0x38, 0x66, + 0x52, 0xe0, 0x15, 0x52, 0xf8, 0xf3, 0x89, 0x3a, 0xbe, 0x51, 0x05, 0xd2, 0x6e, 0x99, 0x14, 0x63, + 0x34, 0x54, 0x7d, 0x16, 0x4e, 0xd6, 0xe1, 0x75, 0x16, 0x1e, 0x41, 0x25, 0x18, 0xe5, 0xf5, 0x11, + 0x12, 0x27, 0x66, 0xb0, 0x76, 0xea, 0xb5, 0x83, 0xff, 0x03, 0x79, 0x8b, 0xb0, 0xa2, 0xb6, 0xd1, + 0x50, 0x4d, 0x93, 0x18, 0xa8, 0x20, 0x54, 0xdf, 0x6c, 0xb6, 0xd8, 0x51, 0x8c, 0xc7, 0xe1, 0xff, + 0x95, 0xf1, 0xc8, 0x5a, 0x1d, 0xe4, 0x1d, 0xdb, 0x3a, 0x3c, 0xea, 0xd4, 0x1b, 0xaf, 0x80, 0x1c, + 0x2c, 0xa4, 0x4e, 0x5c, 0xe2, 0x6a, 0x4c, 0x52, 0x1f, 0xaf, 0xc3, 0xf0, 0xc8, 0xfa, 0xfa, 0x6b, + 0xb7, 0xeb, 0x3a, 0x6b, 0xb4, 0xab, 0x8e, 0x8d, 0xd5, 0xe7, 0xba, 0x61, 0xe8, 0xcf, 0x19, 0xa9, + 0x35, 0x56, 0xdd, 0x69, 0x37, 0x35, 0x9d, 0x32, 0x5b, 0xaf, 0xb6, 0x19, 0xd1, 0x56, 0x75, 0x93, + 0x11, 0xdb, 0x54, 0x8d, 0x55, 0x6e, 0xd8, 0xd3, 0x68, 0x55, 0xab, 0x69, 0x3e, 0xbe, 0xf5, 0x4b, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x74, 0x4c, 0x32, 0xc3, 0x7e, 0x21, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3282,3 +3334,75 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{ Streams: []grpc.StreamDesc{}, Metadata: "milvus.proto", } + +// ProxyServiceClient is the client API for ProxyService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ProxyServiceClient interface { + RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error) +} + +type proxyServiceClient struct { + cc *grpc.ClientConn +} + +func NewProxyServiceClient(cc *grpc.ClientConn) ProxyServiceClient { + return &proxyServiceClient{cc} +} + +func (c *proxyServiceClient) RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error) { + out := new(RegisterLinkResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.milvus.ProxyService/RegisterLink", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ProxyServiceServer is the server API for ProxyService service. +type ProxyServiceServer interface { + RegisterLink(context.Context, *commonpb.Empty) (*RegisterLinkResponse, error) +} + +// UnimplementedProxyServiceServer can be embedded to have forward compatible implementations. +type UnimplementedProxyServiceServer struct { +} + +func (*UnimplementedProxyServiceServer) RegisterLink(ctx context.Context, req *commonpb.Empty) (*RegisterLinkResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterLink not implemented") +} + +func RegisterProxyServiceServer(s *grpc.Server, srv ProxyServiceServer) { + s.RegisterService(&_ProxyService_serviceDesc, srv) +} + +func _ProxyService_RegisterLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(commonpb.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ProxyServiceServer).RegisterLink(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.milvus.ProxyService/RegisterLink", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ProxyServiceServer).RegisterLink(ctx, req.(*commonpb.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +var _ProxyService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "milvus.proto.milvus.ProxyService", + HandlerType: (*ProxyServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RegisterLink", + Handler: _ProxyService_RegisterLink_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "milvus.proto", +} diff --git a/internal/proto/proxy_service.proto b/internal/proto/proxy_service.proto index f541e008d4..d6245316da 100644 --- a/internal/proto/proxy_service.proto +++ b/internal/proto/proxy_service.proto @@ -14,10 +14,7 @@ message RegisterNodeRequest { message RegisterNodeResponse { internal.InitParams init_params = 1; -} - -message RegisterLinkResponse { - common.Address address = 1; + common.Status status = 2; } message InvalidateCollMetaCacheRequest { @@ -27,7 +24,6 @@ message InvalidateCollMetaCacheRequest { } service ProxyService { - rpc RegisterLink(common.Empty) returns (RegisterLinkResponse) {} rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse) {} rpc InvalidateCollectionMetaCache(InvalidateCollMetaCacheRequest) returns (common.Status) {} } diff --git a/internal/proto/proxypb/proxy_service.pb.go b/internal/proto/proxypb/proxy_service.pb.go index 42b9fa3c60..ad6fe57521 100644 --- a/internal/proto/proxypb/proxy_service.pb.go +++ b/internal/proto/proxypb/proxy_service.pb.go @@ -75,6 +75,7 @@ func (m *RegisterNodeRequest) GetAddress() *commonpb.Address { type RegisterNodeResponse struct { InitParams *internalpb2.InitParams `protobuf:"bytes,1,opt,name=init_params,json=initParams,proto3" json:"init_params,omitempty"` + Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -112,41 +113,9 @@ func (m *RegisterNodeResponse) GetInitParams() *internalpb2.InitParams { return nil } -type RegisterLinkResponse struct { - Address *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} } -func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) } -func (*RegisterLinkResponse) ProtoMessage() {} -func (*RegisterLinkResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_34ca2fbc94d169de, []int{2} -} - -func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_RegisterLinkResponse.Unmarshal(m, b) -} -func (m *RegisterLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_RegisterLinkResponse.Marshal(b, m, deterministic) -} -func (m *RegisterLinkResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_RegisterLinkResponse.Merge(m, src) -} -func (m *RegisterLinkResponse) XXX_Size() int { - return xxx_messageInfo_RegisterLinkResponse.Size(m) -} -func (m *RegisterLinkResponse) XXX_DiscardUnknown() { - xxx_messageInfo_RegisterLinkResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_RegisterLinkResponse proto.InternalMessageInfo - -func (m *RegisterLinkResponse) GetAddress() *commonpb.Address { +func (m *RegisterNodeResponse) GetStatus() *commonpb.Status { if m != nil { - return m.Address + return m.Status } return nil } @@ -164,7 +133,7 @@ func (m *InvalidateCollMetaCacheRequest) Reset() { *m = InvalidateCollMe func (m *InvalidateCollMetaCacheRequest) String() string { return proto.CompactTextString(m) } func (*InvalidateCollMetaCacheRequest) ProtoMessage() {} func (*InvalidateCollMetaCacheRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_34ca2fbc94d169de, []int{3} + return fileDescriptor_34ca2fbc94d169de, []int{2} } func (m *InvalidateCollMetaCacheRequest) XXX_Unmarshal(b []byte) error { @@ -209,41 +178,39 @@ func (m *InvalidateCollMetaCacheRequest) GetCollectionName() string { func init() { proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.proxy.RegisterNodeRequest") proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.proxy.RegisterNodeResponse") - proto.RegisterType((*RegisterLinkResponse)(nil), "milvus.proto.proxy.RegisterLinkResponse") proto.RegisterType((*InvalidateCollMetaCacheRequest)(nil), "milvus.proto.proxy.InvalidateCollMetaCacheRequest") } func init() { proto.RegisterFile("proxy_service.proto", fileDescriptor_34ca2fbc94d169de) } var fileDescriptor_34ca2fbc94d169de = []byte{ - // 429 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x52, 0x4d, 0x6b, 0x14, 0x41, - 0x10, 0xdd, 0x89, 0x92, 0x60, 0x67, 0x89, 0xd2, 0x11, 0x0c, 0xe3, 0x07, 0x3a, 0x97, 0xe4, 0xe2, - 0x8c, 0xac, 0xe0, 0x55, 0xb2, 0xc1, 0x43, 0xc0, 0x2c, 0x61, 0x02, 0x1e, 0x72, 0x59, 0x7a, 0xa6, - 0x8b, 0xdd, 0xc2, 0x9e, 0xee, 0xb1, 0xbb, 0x66, 0x31, 0xb9, 0x78, 0xf3, 0x17, 0xf8, 0x7f, 0xfc, - 0x6b, 0x32, 0xdd, 0xd9, 0x2f, 0x1c, 0x06, 0xc4, 0x43, 0x6e, 0x53, 0x3d, 0xaf, 0x5e, 0xbd, 0x7a, - 0xf5, 0xd8, 0x61, 0x6d, 0xcd, 0xf7, 0x9b, 0xa9, 0x03, 0xbb, 0xc0, 0x12, 0xd2, 0xda, 0x1a, 0x32, - 0x9c, 0x57, 0xa8, 0x16, 0x8d, 0x0b, 0x55, 0xea, 0x11, 0xf1, 0xb0, 0x34, 0x55, 0x65, 0x74, 0x78, - 0x8b, 0x0f, 0x50, 0x13, 0x58, 0x2d, 0x54, 0xa8, 0x93, 0x1f, 0xec, 0x30, 0x87, 0x19, 0x3a, 0x02, - 0x3b, 0x31, 0x12, 0x72, 0xf8, 0xd6, 0x80, 0x23, 0xfe, 0x8e, 0x3d, 0x2c, 0x84, 0x83, 0xa3, 0xe8, - 0x75, 0x74, 0xb2, 0x3f, 0x7a, 0x91, 0x6e, 0xf1, 0xde, 0x11, 0x5e, 0xb8, 0xd9, 0x58, 0x38, 0xc8, - 0x3d, 0x92, 0x7f, 0x60, 0x7b, 0x42, 0x4a, 0x0b, 0xce, 0x1d, 0xed, 0xf4, 0x34, 0x9d, 0x06, 0x4c, - 0xbe, 0x04, 0x27, 0xd7, 0xec, 0xe9, 0xb6, 0x00, 0x57, 0x1b, 0xed, 0x80, 0x8f, 0xd9, 0x3e, 0x6a, - 0xa4, 0x69, 0x2d, 0xac, 0xa8, 0xdc, 0x9d, 0x90, 0x37, 0xdb, 0x9c, 0xab, 0x5d, 0xce, 0x35, 0xd2, - 0xa5, 0x07, 0xe6, 0x0c, 0x57, 0xdf, 0xc9, 0x64, 0xcd, 0xfd, 0x19, 0xf5, 0xd7, 0x15, 0xf7, 0x86, - 0xd6, 0xe8, 0x5f, 0xb4, 0xfe, 0x8a, 0xd8, 0xab, 0x73, 0xbd, 0x10, 0x0a, 0xa5, 0x20, 0x38, 0x33, - 0x4a, 0x5d, 0x00, 0x89, 0x33, 0x51, 0xce, 0xff, 0xc3, 0xb8, 0x67, 0x6c, 0x4f, 0x16, 0x53, 0x2d, - 0x2a, 0xf0, 0xc6, 0x3d, 0xca, 0x77, 0x65, 0x31, 0x11, 0x15, 0xf0, 0x63, 0xf6, 0xb8, 0x34, 0x4a, - 0x41, 0x49, 0x68, 0x74, 0x00, 0x3c, 0xf0, 0x80, 0x83, 0xf5, 0x73, 0x0b, 0x1c, 0xfd, 0xde, 0x61, - 0xc3, 0xcb, 0xf6, 0xd6, 0x57, 0x21, 0x0c, 0xfc, 0x0b, 0x1b, 0x6e, 0xee, 0xcd, 0xe3, 0x4e, 0x19, - 0x9f, 0xaa, 0x9a, 0x6e, 0xe2, 0x93, 0xf4, 0xef, 0xcc, 0xa4, 0x5d, 0xae, 0x25, 0x03, 0x5e, 0xae, - 0x79, 0xdb, 0x5b, 0xf1, 0xe3, 0xbe, 0xde, 0x8d, 0x38, 0xf5, 0x0f, 0xd9, 0x3c, 0x7b, 0x32, 0xe0, - 0x96, 0xbd, 0xdc, 0xf6, 0x38, 0x6c, 0xba, 0x72, 0x9a, 0x8f, 0xba, 0xc8, 0xfa, 0xcf, 0x12, 0x3f, - 0xef, 0x74, 0xe0, 0x8a, 0x04, 0x35, 0x2e, 0x19, 0x8c, 0x7e, 0x46, 0xec, 0x89, 0x77, 0xb0, 0xd5, - 0xb2, 0x74, 0xf1, 0x1e, 0x84, 0x8c, 0x4f, 0xaf, 0x3f, 0xce, 0x90, 0xe6, 0x4d, 0xd1, 0xfe, 0xc9, - 0x6e, 0x51, 0x29, 0xbc, 0x25, 0x28, 0xe7, 0x59, 0xe8, 0x7a, 0x2b, 0xd1, 0x91, 0xc5, 0xa2, 0x21, - 0x90, 0xd9, 0x32, 0xfd, 0x99, 0xa7, 0xca, 0xfc, 0xf8, 0xba, 0x28, 0x76, 0x7d, 0xf9, 0xfe, 0x4f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x25, 0x02, 0x4c, 0xbc, 0x21, 0x04, 0x00, 0x00, + // 403 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x92, 0x3f, 0xaf, 0xda, 0x30, + 0x14, 0xc5, 0x49, 0x5b, 0x81, 0x6a, 0x10, 0xad, 0x4c, 0xa5, 0xa2, 0xf4, 0x8f, 0xda, 0x2c, 0xb0, + 0x34, 0xa9, 0x82, 0xd4, 0xb5, 0x02, 0x26, 0x06, 0x10, 0x0a, 0x5b, 0x17, 0xe4, 0xc4, 0x57, 0x60, + 0xc9, 0xb1, 0x53, 0xdb, 0x41, 0x2d, 0x4b, 0xb7, 0xae, 0x5d, 0xfa, 0x1d, 0xfb, 0x35, 0xaa, 0xd8, + 0x84, 0xf7, 0xa2, 0x87, 0x78, 0xc3, 0x1b, 0xde, 0x96, 0xeb, 0xfc, 0x7c, 0x72, 0xee, 0x39, 0x41, + 0x83, 0x42, 0xc9, 0x1f, 0x3f, 0xb7, 0x1a, 0xd4, 0x81, 0x65, 0x10, 0x16, 0x4a, 0x1a, 0x89, 0x71, + 0xce, 0xf8, 0xa1, 0xd4, 0x6e, 0x0a, 0x2d, 0xe1, 0xf7, 0x32, 0x99, 0xe7, 0x52, 0xb8, 0x33, 0xbf, + 0xcf, 0x84, 0x01, 0x25, 0x08, 0x77, 0x73, 0xf0, 0x0b, 0x0d, 0x12, 0xd8, 0x31, 0x6d, 0x40, 0xad, + 0x24, 0x85, 0x04, 0xbe, 0x97, 0xa0, 0x0d, 0xfe, 0x8c, 0x9e, 0xa5, 0x44, 0xc3, 0xd0, 0xfb, 0xe0, + 0x8d, 0xbb, 0xf1, 0xdb, 0xb0, 0xa1, 0x7b, 0x12, 0x5c, 0xea, 0xdd, 0x8c, 0x68, 0x48, 0x2c, 0x89, + 0xbf, 0xa0, 0x0e, 0xa1, 0x54, 0x81, 0xd6, 0xc3, 0x27, 0x57, 0x2e, 0x4d, 0x1d, 0x93, 0xd4, 0x70, + 0xf0, 0xc7, 0x43, 0xaf, 0x9a, 0x0e, 0x74, 0x21, 0x85, 0x06, 0x3c, 0x43, 0x5d, 0x26, 0x98, 0xd9, + 0x16, 0x44, 0x91, 0x5c, 0x9f, 0x9c, 0x7c, 0x6c, 0x8a, 0x9e, 0x97, 0x59, 0x08, 0x66, 0xd6, 0x16, + 0x4c, 0x10, 0x3b, 0x3f, 0xe3, 0x09, 0x6a, 0x6b, 0x43, 0x4c, 0x59, 0x7b, 0x7a, 0x73, 0xd1, 0xd3, + 0xc6, 0x22, 0xc9, 0x09, 0x0d, 0xfe, 0x7a, 0xe8, 0xfd, 0x42, 0x1c, 0x08, 0x67, 0x94, 0x18, 0x98, + 0x4b, 0xce, 0x97, 0x60, 0xc8, 0x9c, 0x64, 0xfb, 0x07, 0xc4, 0xf3, 0x1a, 0x75, 0x68, 0xba, 0x15, + 0x24, 0x07, 0x6b, 0xe5, 0x79, 0xd2, 0xa6, 0xe9, 0x8a, 0xe4, 0x80, 0x47, 0xe8, 0x45, 0x26, 0x39, + 0x87, 0xcc, 0x30, 0x29, 0x1c, 0xf0, 0xd4, 0x02, 0xfd, 0x9b, 0xe3, 0x0a, 0x8c, 0xff, 0x79, 0xa8, + 0xb7, 0xae, 0x1a, 0xdd, 0xb8, 0xca, 0x71, 0x86, 0x7a, 0xb7, 0x83, 0xc3, 0xa3, 0xf0, 0x6e, 0xfb, + 0xe1, 0x85, 0x72, 0xfd, 0xf1, 0xfd, 0xa0, 0xeb, 0x20, 0x68, 0x61, 0x85, 0xde, 0x35, 0xb3, 0x70, + 0x8e, 0xce, 0x89, 0xe0, 0xf8, 0x92, 0xd8, 0xf5, 0xf8, 0xfc, 0x6b, 0x35, 0x04, 0xad, 0xf8, 0xb7, + 0x87, 0x5e, 0xda, 0x4d, 0x2b, 0x2f, 0xf5, 0xb6, 0x8f, 0x60, 0x64, 0x36, 0xfd, 0xf6, 0x75, 0xc7, + 0xcc, 0xbe, 0x4c, 0xab, 0x37, 0xd1, 0x91, 0x71, 0xce, 0x8e, 0x06, 0xb2, 0x7d, 0xe4, 0x6e, 0x7d, + 0xa2, 0x4c, 0x1b, 0xc5, 0xd2, 0xd2, 0x00, 0x8d, 0xea, 0x5f, 0x31, 0xb2, 0x52, 0x91, 0xfd, 0x7c, + 0x91, 0xa6, 0x6d, 0x3b, 0x4e, 0xfe, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x2b, 0x26, 0x14, 0xaf, + 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -258,7 +225,6 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ProxyServiceClient interface { - RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error) } @@ -271,15 +237,6 @@ func NewProxyServiceClient(cc *grpc.ClientConn) ProxyServiceClient { return &proxyServiceClient{cc} } -func (c *proxyServiceClient) RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error) { - out := new(RegisterLinkResponse) - err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyService/RegisterLink", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - func (c *proxyServiceClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) { out := new(RegisterNodeResponse) err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyService/RegisterNode", in, out, opts...) @@ -300,7 +257,6 @@ func (c *proxyServiceClient) InvalidateCollectionMetaCache(ctx context.Context, // ProxyServiceServer is the server API for ProxyService service. type ProxyServiceServer interface { - RegisterLink(context.Context, *commonpb.Empty) (*RegisterLinkResponse, error) RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error) InvalidateCollectionMetaCache(context.Context, *InvalidateCollMetaCacheRequest) (*commonpb.Status, error) } @@ -309,9 +265,6 @@ type ProxyServiceServer interface { type UnimplementedProxyServiceServer struct { } -func (*UnimplementedProxyServiceServer) RegisterLink(ctx context.Context, req *commonpb.Empty) (*RegisterLinkResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RegisterLink not implemented") -} func (*UnimplementedProxyServiceServer) RegisterNode(ctx context.Context, req *RegisterNodeRequest) (*RegisterNodeResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RegisterNode not implemented") } @@ -323,24 +276,6 @@ func RegisterProxyServiceServer(s *grpc.Server, srv ProxyServiceServer) { s.RegisterService(&_ProxyService_serviceDesc, srv) } -func _ProxyService_RegisterLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(commonpb.Empty) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(ProxyServiceServer).RegisterLink(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/milvus.proto.proxy.ProxyService/RegisterLink", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ProxyServiceServer).RegisterLink(ctx, req.(*commonpb.Empty)) - } - return interceptor(ctx, in, info, handler) -} - func _ProxyService_RegisterNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RegisterNodeRequest) if err := dec(in); err != nil { @@ -381,10 +316,6 @@ var _ProxyService_serviceDesc = grpc.ServiceDesc{ ServiceName: "milvus.proto.proxy.ProxyService", HandlerType: (*ProxyServiceServer)(nil), Methods: []grpc.MethodDesc{ - { - MethodName: "RegisterLink", - Handler: _ProxyService_RegisterLink_Handler, - }, { MethodName: "RegisterNode", Handler: _ProxyService_RegisterNode_Handler, diff --git a/internal/proxynode/paramtable.go b/internal/proxynode/paramtable.go index c3646bc8d6..8dcce983df 100644 --- a/internal/proxynode/paramtable.go +++ b/internal/proxynode/paramtable.go @@ -66,6 +66,12 @@ func (pt *ParamTable) NetworkAddress() string { } func (pt *ParamTable) ProxyServiceAddress() string { + addressFromEnv := os.Getenv("PROXY_SERVICE_ADDRESS") + if len(addressFromEnv) > 0 { + // TODO: or write to param table? + return addressFromEnv + } + addr, err := pt.Load("proxyService.address") if err != nil { panic(err) diff --git a/internal/proxynode/proxy_node.go b/internal/proxynode/proxy_node.go index 838e351585..b9334f453b 100644 --- a/internal/proxynode/proxy_node.go +++ b/internal/proxynode/proxy_node.go @@ -11,6 +11,8 @@ import ( "github.com/zilliztech/milvus-distributed/internal/msgstream/pulsarms" + grpcproxyservice "github.com/zilliztech/milvus-distributed/internal/distributed/proxyservice" + "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" "github.com/opentracing/opentracing-go" @@ -32,9 +34,10 @@ type NodeImpl struct { cancel func() wg sync.WaitGroup - initParams *internalpb2.InitParams - ip string - port int + proxyServiceClient *grpcproxyservice.Client + initParams *internalpb2.InitParams + ip string + port int masterConn *grpc.ClientConn masterClient masterpb.MasterServiceClient diff --git a/internal/proxyservice/impl.go b/internal/proxyservice/impl.go new file mode 100644 index 0000000000..69ccea1336 --- /dev/null +++ b/internal/proxyservice/impl.go @@ -0,0 +1,145 @@ +package proxyservice + +import ( + "context" + "fmt" + "time" + + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + + "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" + + "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" +) + +const ( + timeoutInterval = time.Second * 10 +) + +func (s ServiceImpl) Init() error { + return nil +} + +func (s *ServiceImpl) Start() error { + s.sched.Start() + return nil +} + +func (s *ServiceImpl) Stop() error { + s.sched.Close() + return nil +} + +func (s *ServiceImpl) GetComponentStates() (*internalpb2.ComponentStates, error) { + panic("implement me") +} + +func (s *ServiceImpl) GetTimeTickChannel() (string, error) { + panic("implement me") +} + +func (s *ServiceImpl) GetStatisticsChannel() (string, error) { + panic("implement me") +} + +func (s *ServiceImpl) RegisterLink() (*milvuspb.RegisterLinkResponse, error) { + fmt.Println("register link") + ctx, cancel := context.WithTimeout(s.ctx, timeoutInterval) + defer cancel() + + t := &RegisterLinkTask{ + Condition: NewTaskCondition(ctx), + nodeInfos: s.nodeInfos, + } + + var err error + + err = s.sched.RegisterLinkTaskQueue.Enqueue(t) + if err != nil { + return &milvuspb.RegisterLinkResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, + Reason: err.Error(), + }, + Address: nil, + }, nil + } + + err = t.WaitToFinish() + if err != nil { + return &milvuspb.RegisterLinkResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, + Reason: err.Error(), + }, + Address: nil, + }, nil + } + + return t.response, nil +} + +func (s *ServiceImpl) RegisterNode(request *proxypb.RegisterNodeRequest) (*proxypb.RegisterNodeResponse, error) { + fmt.Println("RegisterNode: ", request) + ctx, cancel := context.WithTimeout(s.ctx, timeoutInterval) + defer cancel() + + t := &RegisterNodeTask{ + request: request, + Condition: NewTaskCondition(ctx), + allocator: s.allocator, + nodeInfos: s.nodeInfos, + } + + var err error + + err = s.sched.RegisterNodeTaskQueue.Enqueue(t) + if err != nil { + return &proxypb.RegisterNodeResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, + Reason: err.Error(), + }, + InitParams: nil, + }, nil + } + + err = t.WaitToFinish() + if err != nil { + return &proxypb.RegisterNodeResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, + Reason: err.Error(), + }, + InitParams: nil, + }, nil + } + + return t.response, nil +} + +func (s *ServiceImpl) InvalidateCollectionMetaCache(request *proxypb.InvalidateCollMetaCacheRequest) error { + fmt.Println("InvalidateCollectionMetaCache") + ctx, cancel := context.WithTimeout(s.ctx, timeoutInterval) + defer cancel() + + t := &InvalidateCollectionMetaCacheTask{ + request: request, + Condition: NewTaskCondition(ctx), + } + + var err error + + err = s.sched.RegisterNodeTaskQueue.Enqueue(t) + if err != nil { + return err + } + + err = t.WaitToFinish() + if err != nil { + return err + } + + return nil +} diff --git a/internal/proxyservice/interface.go b/internal/proxyservice/interface.go new file mode 100644 index 0000000000..7171a4465a --- /dev/null +++ b/internal/proxyservice/interface.go @@ -0,0 +1,19 @@ +package proxyservice + +import ( + "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" + "github.com/zilliztech/milvus-distributed/internal/util/typeutil" +) + +type Component = typeutil.Component +type Service = typeutil.Service + +type ProxyService interface { + Component + Service + RegisterLink() (*milvuspb.RegisterLinkResponse, error) + RegisterNode(request *proxypb.RegisterNodeRequest) (*proxypb.RegisterNodeResponse, error) + // TODO: i'm sure it's not a best way to keep consistency, fix me + InvalidateCollectionMetaCache(request *proxypb.InvalidateCollMetaCacheRequest) error +} diff --git a/internal/proxyservice/node_info.go b/internal/proxyservice/node_info.go new file mode 100644 index 0000000000..7de22d001a --- /dev/null +++ b/internal/proxyservice/node_info.go @@ -0,0 +1,116 @@ +package proxyservice + +import ( + "fmt" + "math/rand" + "sync" + "time" + + "github.com/zilliztech/milvus-distributed/internal/errors" + + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" +) + +type NodeInfo struct { + ip string + port int64 +} + +// TODO: replace as real node client impl +type NodeClient interface { + InvalidateCollectionMetaCache(request *proxypb.InvalidateCollMetaCacheRequest) error +} + +type FakeNodeClient struct { +} + +func (c *FakeNodeClient) InvalidateCollectionMetaCache(request *proxypb.InvalidateCollMetaCacheRequest) error { + panic("implement me") +} + +type GlobalNodeInfoTable struct { + mtx sync.RWMutex + nodeIDs []UniqueID + infos map[UniqueID]*NodeInfo + createClientMtx sync.RWMutex + // lazy creating, so len(clients) <= len(infos) + clients map[UniqueID]NodeClient +} + +func (table *GlobalNodeInfoTable) randomPick() UniqueID { + rand.Seed(time.Now().UnixNano()) + l := len(table.nodeIDs) + choice := rand.Intn(l) + return table.nodeIDs[choice] +} + +func (table *GlobalNodeInfoTable) Pick() (*NodeInfo, error) { + table.mtx.RLock() + defer table.mtx.RUnlock() + + if len(table.nodeIDs) <= 0 || len(table.infos) <= 0 { + return nil, errors.New("no available server node") + } + + id := table.randomPick() + info, ok := table.infos[id] + if !ok { + // though impossible + return nil, errors.New("fix me, something wrong in pick algorithm") + } + + return info, nil +} + +func (table *GlobalNodeInfoTable) Register(id UniqueID, info *NodeInfo) error { + table.mtx.Lock() + defer table.mtx.Unlock() + + _, ok := table.infos[id] + if !ok { + table.infos[id] = info + } + + if !SliceContain(table.nodeIDs, id) { + table.nodeIDs = append(table.nodeIDs, id) + } + + return nil +} + +func (table *GlobalNodeInfoTable) createClients() error { + if len(table.clients) == len(table.infos) { + return nil + } + + for nodeID, info := range table.infos { + _, ok := table.clients[nodeID] + if !ok { + // TODO: use info to create client + fmt.Println(info) + table.clients[nodeID] = &FakeNodeClient{} + } + } + + return nil +} + +func (table *GlobalNodeInfoTable) ObtainAllClients() (map[UniqueID]NodeClient, error) { + table.mtx.RLock() + defer table.mtx.RUnlock() + + table.createClientMtx.Lock() + defer table.createClientMtx.Unlock() + + err := table.createClients() + + return table.clients, err +} + +func NewGlobalNodeInfoTable() *GlobalNodeInfoTable { + return &GlobalNodeInfoTable{ + nodeIDs: make([]UniqueID, 0), + infos: make(map[UniqueID]*NodeInfo), + clients: make(map[UniqueID]NodeClient), + } +} diff --git a/internal/proxyservice/nodeid_allocator.go b/internal/proxyservice/nodeid_allocator.go new file mode 100644 index 0000000000..4813bc7ff7 --- /dev/null +++ b/internal/proxyservice/nodeid_allocator.go @@ -0,0 +1,33 @@ +package proxyservice + +import ( + "sync" + + "github.com/zilliztech/milvus-distributed/internal/util/typeutil" +) + +type UniqueID = typeutil.UniqueID + +type NodeIDAllocator interface { + AllocOne() UniqueID +} + +type NaiveNodeIDAllocatorImpl struct { + mtx sync.Mutex + now UniqueID +} + +func (allocator *NaiveNodeIDAllocatorImpl) AllocOne() UniqueID { + allocator.mtx.Lock() + defer func() { + allocator.now++ + allocator.mtx.Unlock() + }() + return allocator.now +} + +func NewNodeIDAllocator() NodeIDAllocator { + return &NaiveNodeIDAllocatorImpl{ + now: 0, + } +} diff --git a/internal/proxyservice/proxyservice.go b/internal/proxyservice/proxyservice.go index 29c9f8721a..2a6eb31597 100644 --- a/internal/proxyservice/proxyservice.go +++ b/internal/proxyservice/proxyservice.go @@ -1,54 +1,31 @@ package proxyservice import ( - "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" - "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" + "context" + "math/rand" + "time" ) -type ProxyService struct { - // implement Service - - //nodeClients [] .Interface - // factory method +type ServiceImpl struct { + allocator NodeIDAllocator + sched *TaskScheduler + nodeInfos *GlobalNodeInfoTable + ctx context.Context + cancel context.CancelFunc } -func (s ProxyService) Init() error { - panic("implement me") -} +func CreateProxyService(ctx context.Context) (ProxyService, error) { + rand.Seed(time.Now().UnixNano()) + ctx1, cancel := context.WithCancel(ctx) + s := &ServiceImpl{ + ctx: ctx1, + cancel: cancel, + } -func (s ProxyService) Start() error { - panic("implement me") -} + s.allocator = NewNodeIDAllocator() + s.sched = NewTaskScheduler(ctx1) + s.nodeInfos = NewGlobalNodeInfoTable() -func (s ProxyService) Stop() error { - panic("implement me") -} - -func (s ProxyService) GetComponentStates() (*internalpb2.ComponentStates, error) { - panic("implement me") -} - -func (s ProxyService) GetTimeTickChannel() (string, error) { - panic("implement me") -} - -func (s ProxyService) GetStatisticsChannel() (string, error) { - panic("implement me") -} - -func (s ProxyService) RegisterLink() (proxypb.RegisterLinkResponse, error) { - panic("implement me") -} - -func (s ProxyService) RegisterNode(request proxypb.RegisterNodeRequest) (proxypb.RegisterNodeResponse, error) { - panic("implement me") -} - -func (s ProxyService) InvalidateCollectionMetaCache(request proxypb.InvalidateCollMetaCacheRequest) error { - panic("implement me") -} - -func NewProxyServiceImpl() interface{} { - return &ProxyService{} + return s, nil } diff --git a/internal/proxyservice/task.go b/internal/proxyservice/task.go new file mode 100644 index 0000000000..277617255a --- /dev/null +++ b/internal/proxyservice/task.go @@ -0,0 +1,157 @@ +package proxyservice + +import ( + "context" + "fmt" + + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + + "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" + + "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" + + "github.com/zilliztech/milvus-distributed/internal/proto/proxypb" + + "github.com/zilliztech/milvus-distributed/internal/errors" +) + +type TaskEnum = int + +const ( + FromSDK TaskEnum = 0 + FromMaster TaskEnum = 1 + FromNode TaskEnum = 2 +) + +type task interface { + PreExecute() error + Execute() error + PostExecute() error + WaitToFinish() error + Notify(err error) +} + +type Condition interface { + WaitToFinish() error + Notify(err error) +} + +type TaskCondition struct { + done chan error + ctx context.Context +} + +func (c *TaskCondition) WaitToFinish() error { + select { + case <-c.ctx.Done(): + return errors.New("timeout") + case err := <-c.done: + return err + } +} + +func (c *TaskCondition) Notify(err error) { + c.done <- err +} + +func NewTaskCondition(ctx context.Context) Condition { + return &TaskCondition{ + done: make(chan error), + ctx: ctx, + } +} + +type RegisterLinkTask struct { + Condition + response *milvuspb.RegisterLinkResponse + nodeInfos *GlobalNodeInfoTable +} + +func (t *RegisterLinkTask) PreExecute() error { + return nil +} + +func (t *RegisterLinkTask) Execute() error { + info, err := t.nodeInfos.Pick() + fmt.Println("info: ", info) + if err != nil { + return err + } + t.response = &milvuspb.RegisterLinkResponse{ + Address: &commonpb.Address{ + Ip: info.ip, + Port: info.port, + }, + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_SUCCESS, + Reason: "", + }, + } + return nil +} + +func (t *RegisterLinkTask) PostExecute() error { + return nil +} + +type RegisterNodeTask struct { + Condition + request *proxypb.RegisterNodeRequest + response *proxypb.RegisterNodeResponse + allocator NodeIDAllocator + nodeInfos *GlobalNodeInfoTable +} + +func (t *RegisterNodeTask) PreExecute() error { + return nil +} + +func (t *RegisterNodeTask) Execute() error { + nodeID := t.allocator.AllocOne() + info := NodeInfo{ + ip: t.request.Address.Ip, + port: t.request.Address.Port, + } + err := t.nodeInfos.Register(nodeID, &info) + // TODO: fill init params + t.response = &proxypb.RegisterNodeResponse{ + InitParams: &internalpb2.InitParams{ + NodeID: nodeID, + StartParams: nil, + }, + } + return err +} + +func (t *RegisterNodeTask) PostExecute() error { + return nil +} + +type InvalidateCollectionMetaCacheTask struct { + Condition + request *proxypb.InvalidateCollMetaCacheRequest + nodeInfos *GlobalNodeInfoTable +} + +func (t *InvalidateCollectionMetaCacheTask) PreExecute() error { + return nil +} + +func (t *InvalidateCollectionMetaCacheTask) Execute() error { + var err error + clients, err := t.nodeInfos.ObtainAllClients() + if err != nil { + return err + } + for _, c := range clients { + err = c.InvalidateCollectionMetaCache(t.request) + if err != nil { + return err + } + } + return nil +} + +func (t *InvalidateCollectionMetaCacheTask) PostExecute() error { + return nil +} diff --git a/internal/proxyservice/task_queue.go b/internal/proxyservice/task_queue.go new file mode 100644 index 0000000000..f1a01ff9d8 --- /dev/null +++ b/internal/proxyservice/task_queue.go @@ -0,0 +1,92 @@ +package proxyservice + +import ( + "container/list" + "log" + "sync" + + "github.com/zilliztech/milvus-distributed/internal/errors" +) + +type TaskQueue interface { + Chan() <-chan int + Empty() bool + Full() bool + addTask(t task) error + FrontTask() task + PopTask() task + Enqueue(t task) error +} + +type BaseTaskQueue struct { + tasks *list.List + mtx sync.Mutex + + // maxTaskNum should keep still + maxTaskNum int64 + + bufChan chan int // to block scheduler +} + +func (queue *BaseTaskQueue) Chan() <-chan int { + return queue.bufChan +} + +func (queue *BaseTaskQueue) Empty() bool { + return queue.tasks.Len() <= 0 +} + +func (queue *BaseTaskQueue) Full() bool { + return int64(queue.tasks.Len()) >= queue.maxTaskNum +} + +func (queue *BaseTaskQueue) addTask(t task) error { + queue.mtx.Lock() + defer queue.mtx.Unlock() + + if queue.Full() { + return errors.New("task queue is full") + } + queue.tasks.PushBack(t) + queue.bufChan <- 1 + return nil +} + +func (queue *BaseTaskQueue) FrontTask() task { + queue.mtx.Lock() + defer queue.mtx.Unlock() + + if queue.tasks.Len() <= 0 { + log.Panic("sorry, but the task list is empty!") + return nil + } + + return queue.tasks.Front().Value.(task) +} + +func (queue *BaseTaskQueue) PopTask() task { + queue.mtx.Lock() + defer queue.mtx.Unlock() + + if queue.tasks.Len() <= 0 { + log.Panic("sorry, but the task list is empty!") + return nil + } + + ft := queue.tasks.Front() + queue.tasks.Remove(ft) + + return ft.Value.(task) +} + +func (queue *BaseTaskQueue) Enqueue(t task) error { + return queue.addTask(t) +} + +func NewBaseTaskQueue() TaskQueue { + return &BaseTaskQueue{ + tasks: list.New(), + maxTaskNum: 1024, + bufChan: make(chan int, 1024), + } +} diff --git a/internal/proxyservice/task_scheduler.go b/internal/proxyservice/task_scheduler.go new file mode 100644 index 0000000000..1194c918c1 --- /dev/null +++ b/internal/proxyservice/task_scheduler.go @@ -0,0 +1,119 @@ +package proxyservice + +import ( + "context" + "sync" +) + +type TaskScheduler struct { + RegisterLinkTaskQueue TaskQueue + RegisterNodeTaskQueue TaskQueue + InvalidateCollectionMetaCacheTaskQueue TaskQueue + + wg sync.WaitGroup + ctx context.Context + cancel context.CancelFunc +} + +func NewTaskScheduler(ctx context.Context) *TaskScheduler { + ctx1, cancel := context.WithCancel(ctx) + + return &TaskScheduler{ + RegisterLinkTaskQueue: NewBaseTaskQueue(), + RegisterNodeTaskQueue: NewBaseTaskQueue(), + InvalidateCollectionMetaCacheTaskQueue: NewBaseTaskQueue(), + ctx: ctx1, + cancel: cancel, + } +} + +func (sched *TaskScheduler) scheduleRegisterLinkTask() task { + return sched.RegisterLinkTaskQueue.PopTask() +} + +func (sched *TaskScheduler) scheduleRegisterNodeTask() task { + return sched.RegisterNodeTaskQueue.PopTask() +} + +func (sched *TaskScheduler) scheduleInvalidateCollectionMetaCacheTask() task { + return sched.InvalidateCollectionMetaCacheTaskQueue.PopTask() +} + +func (sched *TaskScheduler) processTask(t task, q TaskQueue) { + var err error + err = t.PreExecute() + + defer func() { + t.Notify(err) + }() + if err != nil { + return + } + + err = t.Execute() + if err != nil { + return + } + err = t.PostExecute() +} + +func (sched *TaskScheduler) registerLinkLoop() { + defer sched.wg.Done() + for { + select { + case <-sched.ctx.Done(): + return + case <-sched.RegisterLinkTaskQueue.Chan(): + if !sched.RegisterLinkTaskQueue.Empty() { + t := sched.scheduleRegisterLinkTask() + go sched.processTask(t, sched.RegisterLinkTaskQueue) + } + } + } +} + +func (sched *TaskScheduler) registerNodeLoop() { + defer sched.wg.Done() + for { + select { + case <-sched.ctx.Done(): + return + case <-sched.RegisterNodeTaskQueue.Chan(): + if !sched.RegisterNodeTaskQueue.Empty() { + t := sched.scheduleRegisterNodeTask() + go sched.processTask(t, sched.RegisterNodeTaskQueue) + } + } + } +} + +func (sched *TaskScheduler) invalidateCollectionMetaCacheLoop() { + defer sched.wg.Done() + for { + select { + case <-sched.ctx.Done(): + return + case <-sched.InvalidateCollectionMetaCacheTaskQueue.Chan(): + if !sched.InvalidateCollectionMetaCacheTaskQueue.Empty() { + t := sched.scheduleInvalidateCollectionMetaCacheTask() + go sched.processTask(t, sched.InvalidateCollectionMetaCacheTaskQueue) + } + } + } +} + +func (sched *TaskScheduler) Start() { + sched.wg.Add(1) + go sched.registerLinkLoop() + + sched.wg.Add(1) + go sched.registerNodeLoop() + + sched.wg.Add(1) + go sched.invalidateCollectionMetaCacheLoop() +} + +func (sched *TaskScheduler) Close() { + sched.cancel() + sched.wg.Wait() +} diff --git a/internal/proxyservice/utils.go b/internal/proxyservice/utils.go new file mode 100644 index 0000000000..33246fa60d --- /dev/null +++ b/internal/proxyservice/utils.go @@ -0,0 +1,21 @@ +package proxyservice + +import ( + "reflect" +) + +// what if golang support generic programming +func SliceContain(s interface{}, item interface{}) bool { + ss := reflect.ValueOf(s) + if ss.Kind() != reflect.Slice { + panic("SliceContain expect a slice") + } + + for i := 0; i < ss.Len(); i++ { + if ss.Index(i).Interface() == item { + return true + } + } + + return false +} diff --git a/tests/python/requirements.txt b/tests/python/requirements.txt index f0f095a96e..f41ff379e7 100644 --- a/tests/python/requirements.txt +++ b/tests/python/requirements.txt @@ -4,5 +4,5 @@ numpy==1.18.1 pytest==5.3.4 pytest-cov==2.8.1 pytest-timeout==1.3.4 -pymilvus-distributed==0.0.16 +pymilvus-distributed==0.0.17 sklearn==0.0