Add tikv storage,proxy pulsar thirdparty

Signed-off-by: Nshengjh <1572099106@qq.com>

proxy/CMakeLists.txt

@@ -48,7 +48,6 @@ set( MILVUS_SOURCE_DIR      ${PROJECT_SOURCE_DIR} )
 set( MILVUS_BINARY_DIR      ${PROJECT_BINARY_DIR} )
 set( MILVUS_ENGINE_SRC      ${PROJECT_SOURCE_DIR}/src )
 set( MILVUS_THIRDPARTY_SRC  ${PROJECT_SOURCE_DIR}/thirdparty )
-set(pulsar_ROOT "${MILVUS_BINARY_DIR}/thirdparty/pulsar" CACHE STRING "")
 
 # This will set RPATH to all excutable TARGET
 # self-installed dynamic libraries will be correctly linked by excutable

proxy/conf/demo/server_config.yaml

+# 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.
+
+version: 0.5
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cluster Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | If runinng with Mishards, set true, otherwise false.       | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# role                 | Milvus deployment role: rw / ro                            | role       | rw              |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cluster:
+  enable: false
+  role: rw
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# General Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# time_zone            | Use UTC-x or UTC+x to specify a time zone.                 | Timezone   | UTC+8           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# meta_uri             | URI for metadata storage, using SQLite (for single server  | URL        | sqlite://:@:/   |
+#                      | Milvus) or MySQL (for distributed cluster Milvus).         |            |                 |
+#                      | Format: dialect://username:password@host:port/database     |            |                 |
+#                      | Keep 'dialect://:@:/', 'dialect' can be either 'sqlite' or |            |                 |
+#                      | 'mysql', replace other texts with real values.             |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+general:
+  timezone: UTC+8
+  meta_uri: sqlite://:@:/
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Network Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.address         | IP address that Milvus server monitors.                    | IP         | 0.0.0.0         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.port            | Port that Milvus server monitors. Port range (1024, 65535) | Integer    | 19530           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.enable          | Enable web server or not.                                  | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.port            | Port that Milvus web server monitors.                      | Integer    | 19121           |
+#                      | Port range (1024, 65535)                                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+network: 
+  bind.address: 0.0.0.0
+  bind.port: 19530
+  http.enable: true
+  http.port: 19121
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Storage Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Path used to save meta data, vector data and index data.   | Path       | /var/lib/milvus |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# auto_flush_interval  | The interval, in seconds, at which Milvus automatically    | Integer    | 1 (s)           |
+#                      | flushes data to disk.                                      |            |                 |
+#                      | 0 means disable the regular flush.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+storage:
+  path: /var/lib/milvus
+  auto_flush_interval: 1
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# WAL Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Whether to enable write-ahead logging (WAL) in Milvus.     | Boolean    | true            |
+#                      | If WAL is enabled, Milvus writes all data changes to log   |            |                 |
+#                      | files in advance before implementing data changes. WAL     |            |                 |
+#                      | ensures the atomicity and durability for Milvus operations.|            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# recovery_error_ignore| Whether to ignore logs with errors that happens during WAL | Boolean    | false           |
+#                      | recovery. If true, when Milvus restarts for recovery and   |            |                 |
+#                      | there are errors in WAL log files, log files with errors   |            |                 |
+#                      | are ignored. If false, Milvus does not restart when there  |            |                 |
+#                      | are errors in WAL log files.                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# buffer_size          | Sum total of the read buffer and the write buffer in MBs.  | Integer    | 256 (MB)        |
+#                      | buffer_size must be in range [64, 4096] (MB).              |            |                 |
+#                      | If the value you specified is out of range, Milvus         |            |                 |
+#                      | automatically uses the boundary value closest to the       |            |                 |
+#                      | specified value. It is recommended you set buffer_size to  |            |                 |
+#                      | a value greater than the inserted data size of a single    |            |                 |
+#                      | insert operation for better performance.                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Location of WAL log files.                                 | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+wal:
+  enable: true
+  recovery_error_ignore: false
+  buffer_size: 256MB
+  path: /var/lib/milvus/wal
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cache Config         | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of CPU memory used for caching data for faster    | Integer    | 4 (GB)          |
+#                      | query. The sum of 'cpu_cache_capacity' and                 |            |                 |
+#                      | 'insert_buffer_size' must be less than system memory size. |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# insert_buffer_size   | Buffer size used for data insertion.                       | Integer    | 1 (GB)          |
+#                      | The sum of 'insert_buffer_size' and 'cpu_cache_capacity'   |            |                 |
+#                      | must be less than system memory size.                      |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# preload_collection   | A comma-separated list of collection names that need to    | StringList |                 |
+#                      | be pre-loaded when Milvus server starts up.                |            |                 |
+#                      | '*' means preload all existing tables (single-quote or     |            |                 |
+#                      | double-quote required).                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cache:
+  cache_size: 4GB
+  insert_buffer_size: 1GB
+  preload_collection:
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# GPU Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Enable GPU resources or not.                               | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of GPU memory per card used for cache.            | Integer    | 1 (GB)          |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# gpu_search_threshold | A Milvus performance tuning parameter. This value will be  | Integer    | 1000            |
+#                      | compared with 'nq' to decide if the search computation will|            |                 |
+#                      | be executed on GPUs only.                                  |            |                 |
+#                      | If nq >= gpu_search_threshold, the search computation will |            |                 |
+#                      | be executed on GPUs only;                                  |            |                 |
+#                      | if nq < gpu_search_threshold, the search computation will  |            |                 |
+#                      | be executed on both CPUs and GPUs.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# search_resources     | The list of GPU devices used for search computation.       | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# build_index_resources| The list of GPU devices used for index building.           | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+gpu:
+  enable: false
+  cache_size: 1GB
+  gpu_search_threshold: 1000
+  search_devices:
+    - gpu0
+  build_index_devices:
+    - gpu0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Logs Config          | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# level                | Log level in Milvus. Must be one of debug, info, warning,  | String     | debug           |
+#                      | error, fatal                                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# trace.enable         | Whether to enable trace level logging in Milvus.           | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Absolute path to the folder holding the log files.         | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# max_log_file_size    | The maximum size of each log file, size range [512, 4096]  | Integer    | 1024 (MB)       |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# log_rotate_num       | The maximum number of log files that Milvus keeps for each | Integer    | 0               |
+#                      | logging level, num range [0, 1024], 0 means unlimited.     |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+logs:
+  level: debug
+  trace.enable: true
+  path: /var/lib/milvus/logs
+  max_log_file_size: 1024MB
+  log_rotate_num: 0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Metric Config        | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Enable monitoring function or not.                         | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# address              | Pushgateway address                                        | IP         | 127.0.0.1       +
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# port                 | Pushgateway port, port range (1024, 65535)                 | Integer    | 9091            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+metric:
+  enable: false
+  address: 127.0.0.1
+  port: 9091
+

proxy/conf/log_config.conf

+* GLOBAL:
+    FORMAT                  =   "%datetime | %level | %logger | %msg"
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-global.log"
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    SUBSECOND_PRECISION     =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   209715200 ## Throw log files away after 200MB
+* DEBUG:
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-debug.log"
+    ENABLED                 =   true
+* WARNING:
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-warning.log"
+* TRACE:
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-trace.log"
+* VERBOSE:
+    FORMAT                  =   "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
+    TO_FILE                 =   false
+    TO_STANDARD_OUTPUT      =   false
+## Error logs
+* ERROR:
+    ENABLED                 =   true
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-error.log"
+* FATAL:
+    ENABLED                 =   true
+    FILENAME                =   "/usr/local/logs/milvus-%datetime{%y-%M-%d-%H:%m}-fatal.log"

proxy/conf/server_config.template

+# 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.
+
+version: 0.5
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cluster Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | If running with Mishards, set true, otherwise false.       | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# role                 | Milvus deployment role: rw / ro                            | Role       | rw              |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cluster:
+  enable: false
+  role: rw
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# General Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# timezone             | Use UTC-x or UTC+x to specify a time zone.                 | Timezone   | UTC+8           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# meta_uri             | URI for metadata storage, using SQLite (for single server  | URI        | sqlite://:@:/   |
+#                      | Milvus) or MySQL (for distributed cluster Milvus).         |            |                 |
+#                      | Format: dialect://username:password@host:port/database     |            |                 |
+#                      | Keep 'dialect://:@:/', 'dialect' can be either 'sqlite' or |            |                 |
+#                      | 'mysql', replace other texts with real values.             |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+general:
+  timezone: UTC+8
+  meta_uri: sqlite://:@:/
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Network Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.address         | IP address that Milvus server monitors.                    | IP         | 0.0.0.0         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.port            | Port that Milvus server monitors. Port range (1024, 65535) | Integer    | 19530           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.enable          | Enable HTTP server or not.                                 | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.port            | Port that Milvus HTTP server monitors.                     | Integer    | 19121           |
+#                      | Port range (1024, 65535)                                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+network: 
+  bind.address: 0.0.0.0
+  bind.port: 19530
+  http.enable: true
+  http.port: 19121
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Storage Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Path used to save meta data, vector data and index data.   | Path       | /var/lib/milvus |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# auto_flush_interval  | The interval, in seconds, at which Milvus automatically    | Integer    | 1 (s)           |
+#                      | flushes data to disk.                                      |            |                 |
+#                      | 0 means disable the regular flush.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+storage:
+  path: @MILVUS_DB_PATH@
+  auto_flush_interval: 1
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# WAL Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Whether to enable write-ahead logging (WAL) in Milvus.     | Boolean    | true            |
+#                      | If WAL is enabled, Milvus writes all data changes to log   |            |                 |
+#                      | files in advance before implementing data changes. WAL     |            |                 |
+#                      | ensures the atomicity and durability for Milvus operations.|            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# recovery_error_ignore| Whether to ignore logs with errors that happens during WAL | Boolean    | false           |
+#                      | recovery. If true, when Milvus restarts for recovery and   |            |                 |
+#                      | there are errors in WAL log files, log files with errors   |            |                 |
+#                      | are ignored. If false, Milvus does not restart when there  |            |                 |
+#                      | are errors in WAL log files.                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# buffer_size          | Sum total of the read buffer and the write buffer in Bytes.| String     | 256MB           |
+#                      | buffer_size must be in range [64MB, 4096MB].               |            |                 |
+#                      | If the value you specified is out of range, Milvus         |            |                 |
+#                      | automatically uses the boundary value closest to the       |            |                 |
+#                      | specified value. It is recommended you set buffer_size to  |            |                 |
+#                      | a value greater than the inserted data size of a single    |            |                 |
+#                      | insert operation for better performance.                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Location of WAL log files.                                 | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+wal:
+  enable: true
+  recovery_error_ignore: false
+  buffer_size: 256MB
+  path: @MILVUS_DB_PATH@/wal
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cache Config         | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of CPU memory used for caching data for faster    | String     | 4GB             |
+#                      | query. The sum of 'cache_size' and 'insert_buffer_size'    |            |                 |
+#                      | must be less than system memory size.                      |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# insert_buffer_size   | Buffer size used for data insertion.                       | String     | 1GB             |
+#                      | The sum of 'insert_buffer_size' and 'cache_size'           |            |                 |
+#                      | must be less than system memory size.                      |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# preload_collection   | A comma-separated list of collection names that need to    | StringList |                 |
+#                      | be pre-loaded when Milvus server starts up.                |            |                 |
+#                      | '*' means preload all existing tables (single-quote or     |            |                 |
+#                      | double-quote required).                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cache:
+  cache_size: 4GB
+  insert_buffer_size: 1GB
+  preload_collection:
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# GPU Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Use GPU devices or not.                                    | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of GPU memory per card used for cache.            | String     | 1GB             |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# gpu_search_threshold | A Milvus performance tuning parameter. This value will be  | Integer    | 1000            |
+#                      | compared with 'nq' to decide if the search computation will|            |                 |
+#                      | be executed on GPUs only.                                  |            |                 |
+#                      | If nq >= gpu_search_threshold, the search computation will |            |                 |
+#                      | be executed on GPUs only;                                  |            |                 |
+#                      | if nq < gpu_search_threshold, the search computation will  |            |                 |
+#                      | be executed on both CPUs and GPUs.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# search_devices       | The list of GPU devices used for search computation.       | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# build_index_devices  | The list of GPU devices used for index building.           | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+gpu:
+  enable: @GPU_ENABLE@
+  cache_size: 1GB
+  gpu_search_threshold: 1000
+  search_devices:
+    - gpu0
+  build_index_devices:
+    - gpu0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Logs Config          | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# level                | Log level in Milvus. Must be one of debug, info, warning,  | String     | debug           |
+#                      | error, fatal                                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# trace.enable         | Whether to enable trace level logging in Milvus.           | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Absolute path to the folder holding the log files.         | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# max_log_file_size    | The maximum size of each log file, size range              | String     | 1024MB          |
+#                      | [512MB, 4096MB].                                           |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# log_rotate_num       | The maximum number of log files that Milvus keeps for each | Integer    | 0               |
+#                      | logging level, num range [0, 1024], 0 means unlimited.     |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+logs:
+  level: debug
+  trace.enable: true
+  path: @MILVUS_DB_PATH@/logs
+  max_log_file_size: 1024MB
+  log_rotate_num: 0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Metric Config        | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Enable monitoring function or not.                         | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# address              | Pushgateway address                                        | IP         | 127.0.0.1       +
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# port                 | Pushgateway port, port range (1024, 65535)                 | Integer    | 9091            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+metric:
+  enable: false
+  address: 127.0.0.1
+  port: 9091
+

proxy/conf/server_config.yaml

+# 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.
+
+version: 0.5
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cluster Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | If running with Mishards, set true, otherwise false.       | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# role                 | Milvus deployment role: rw / ro                            | Role       | rw              |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cluster:
+  enable: false
+  role: rw
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# General Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# timezone             | Use UTC-x or UTC+x to specify a time zone.                 | Timezone   | UTC+8           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# meta_uri             | URI for metadata storage, using SQLite (for single server  | URI        | sqlite://:@:/   |
+#                      | Milvus) or MySQL (for distributed cluster Milvus).         |            |                 |
+#                      | Format: dialect://username:password@host:port/database     |            |                 |
+#                      | Keep 'dialect://:@:/', 'dialect' can be either 'sqlite' or |            |                 |
+#                      | 'mysql', replace other texts with real values.             |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+general:
+  timezone: UTC+8
+  meta_uri: sqlite://:@:/
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Network Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.address         | IP address that Milvus server monitors.                    | IP         | 0.0.0.0         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# bind.port            | Port that Milvus server monitors. Port range (1024, 65535) | Integer    | 19530           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.enable          | Enable HTTP server or not.                                 | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# http.port            | Port that Milvus HTTP server monitors.                     | Integer    | 19121           |
+#                      | Port range (1024, 65535)                                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+network: 
+  bind.address: 0.0.0.0
+  bind.port: 19530
+  http.enable: true
+  http.port: 19121
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Storage Config       | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Path used to save meta data, vector data and index data.   | Path       | /var/lib/milvus |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# auto_flush_interval  | The interval, in seconds, at which Milvus automatically    | Integer    | 1 (s)           |
+#                      | flushes data to disk.                                      |            |                 |
+#                      | 0 means disable the regular flush.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+storage:
+  path: /tmp
+  auto_flush_interval: 1
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# WAL Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Whether to enable write-ahead logging (WAL) in Milvus.     | Boolean    | true            |
+#                      | If WAL is enabled, Milvus writes all data changes to log   |            |                 |
+#                      | files in advance before implementing data changes. WAL     |            |                 |
+#                      | ensures the atomicity and durability for Milvus operations.|            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# recovery_error_ignore| Whether to ignore logs with errors that happens during WAL | Boolean    | false           |
+#                      | recovery. If true, when Milvus restarts for recovery and   |            |                 |
+#                      | there are errors in WAL log files, log files with errors   |            |                 |
+#                      | are ignored. If false, Milvus does not restart when there  |            |                 |
+#                      | are errors in WAL log files.                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# buffer_size          | Sum total of the read buffer and the write buffer in Bytes.| String     | 256MB           |
+#                      | buffer_size must be in range [64MB, 4096MB].               |            |                 |
+#                      | If the value you specified is out of range, Milvus         |            |                 |
+#                      | automatically uses the boundary value closest to the       |            |                 |
+#                      | specified value. It is recommended you set buffer_size to  |            |                 |
+#                      | a value greater than the inserted data size of a single    |            |                 |
+#                      | insert operation for better performance.                   |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Location of WAL log files.                                 | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+wal:
+  enable: true
+  recovery_error_ignore: false
+  buffer_size: 256MB
+  path: /tmp/wal
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Cache Config         | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of CPU memory used for caching data for faster    | String     | 4GB             |
+#                      | query. The sum of 'cache_size' and 'insert_buffer_size'    |            |                 |
+#                      | must be less than system memory size.                      |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# insert_buffer_size   | Buffer size used for data insertion.                       | String     | 1GB             |
+#                      | The sum of 'insert_buffer_size' and 'cache_size'           |            |                 |
+#                      | must be less than system memory size.                      |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# preload_collection   | A comma-separated list of collection names that need to    | StringList |                 |
+#                      | be pre-loaded when Milvus server starts up.                |            |                 |
+#                      | '*' means preload all existing tables (single-quote or     |            |                 |
+#                      | double-quote required).                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+cache:
+  cache_size: 4GB
+  insert_buffer_size: 1GB
+  preload_collection:
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# GPU Config           | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Use GPU devices or not.                                    | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# cache_size           | The size of GPU memory per card used for cache.            | String     | 1GB             |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# gpu_search_threshold | A Milvus performance tuning parameter. This value will be  | Integer    | 1000            |
+#                      | compared with 'nq' to decide if the search computation will|            |                 |
+#                      | be executed on GPUs only.                                  |            |                 |
+#                      | If nq >= gpu_search_threshold, the search computation will |            |                 |
+#                      | be executed on GPUs only;                                  |            |                 |
+#                      | if nq < gpu_search_threshold, the search computation will  |            |                 |
+#                      | be executed on both CPUs and GPUs.                         |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# search_devices       | The list of GPU devices used for search computation.       | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# build_index_devices  | The list of GPU devices used for index building.           | DeviceList | gpu0            |
+#                      | Must be in format gpux.                                    |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+gpu:
+  enable: false
+  cache_size: 1GB
+  gpu_search_threshold: 1000
+  search_devices:
+    - gpu0
+  build_index_devices:
+    - gpu0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Logs Config          | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# level                | Log level in Milvus. Must be one of debug, info, warning,  | String     | debug           |
+#                      | error, fatal                                               |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# trace.enable         | Whether to enable trace level logging in Milvus.           | Boolean    | true            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# path                 | Absolute path to the folder holding the log files.         | String     |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# max_log_file_size    | The maximum size of each log file, size range              | String     | 1024MB          |
+#                      | [512MB, 4096MB].                                           |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# log_rotate_num       | The maximum number of log files that Milvus keeps for each | Integer    | 0               |
+#                      | logging level, num range [0, 1024], 0 means unlimited.     |            |                 |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+logs:
+  level: debug
+  trace.enable: true
+  path: /tmp/logs
+  max_log_file_size: 1024MB
+  log_rotate_num: 0
+
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# Metric Config        | Description                                                | Type       | Default         |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# enable               | Enable monitoring function or not.                         | Boolean    | false           |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# address              | Pushgateway address                                        | IP         | 127.0.0.1       +
+#----------------------+------------------------------------------------------------+------------+-----------------+
+# port                 | Pushgateway port, port range (1024, 65535)                 | Integer    | 9091            |
+#----------------------+------------------------------------------------------------+------------+-----------------+
+metric:
+  enable: false
+  address: 127.0.0.1
+  port: 9091
+

proxy/conf/tracing_config.json

+{
+  "host": "127.0.0.1",
+  "port": "5666",
+  "tracer_library": "/path/to/shared_tracing_library",
+  "tracer_configuration": {
+    "service_name": "milvus_server",
+    "sampler": {
+      "type": "const",
+      "param": "1"
+    },
+    "disabled": false,
+    "reporter": {
+      "localAgentHostPort": "127.0.0.1:6831"
+    },
+    "headers": {
+      "jaegerDebugHeader": "jaeger_debug_header",
+      "jaegerBaggageHeader": "jarger_baggage_header",
+      "TraceContextHeaderName": "trace_context_header_name",
+      "traceBaggageHeaderPrefix": "trace_baggage_header_prefix"
+    },
+    "baggage_restrictions": {
+      "denyBaggageOnInitializationFailure": false,
+      "hostPort": ""
+    }
+  }
+}

proxy/src/CMakeLists.txt

@@ -18,9 +18,6 @@ include_directories(${MILVUS_THIRDPARTY_SRC})
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-status)
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-milvus)
 
-include_directories(${pulsar_ROOT}/build/include)
-link_directories(${pulsar_ROOT}/build/lib)
-
 add_subdirectory( tracing )
 add_subdirectory( utils )
 add_subdirectory( config )
@@ -63,7 +60,7 @@ set( THIRD_PARTY_LIBS
 target_link_libraries( server
                 PUBLIC ${link_lib}
                 tracing
-				libpulsar
+				pulsarStatic
                 ${THIRD_PARTY_LIBS}
                 ${BOOST_LIB}
                        )
@@ -80,6 +77,8 @@ set( SERVER_LIBS server )
 
 add_executable( milvus_server   ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
                                 )
+target_include_directories(server PUBLIC ${PROJECT_BINARY_DIR}/thirdparty/pulsar-client-cpp/pulsar-client-cpp-src/pulsar-client-cpp/include)
+
 
 target_link_libraries( milvus_server PRIVATE ${SERVER_LIBS} )
 install( TARGETS milvus_server DESTINATION bin )

proxy/src/grpc/cpp_gen.sh

 #!/bin/bash
 
-../../cmake-build/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-status --plugin=protoc-gen-grpc="../../cmake-build/thirdparty/grpc/grpc-build/grpc_cpp_plugin" status.proto
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-status --plugin=protoc-gen-grpc="../../cmake-build-debug/thirdparty/grpc/grpc-build/grpc_cpp_plugin" status.proto
 
-../../cmake-build/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-status status.proto
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-status status.proto
 
-../../cmake-build/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc="../../cmake-build/thirdparty/grpc/grpc-build/grpc_cpp_plugin" milvus.proto
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc="../../cmake-build-debug/thirdparty/grpc/grpc-build/grpc_cpp_plugin" milvus.proto
 
-../../cmake-build/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-milvus milvus.proto
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-milvus milvus.proto
+
+
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc="../../cmake-build-debug/thirdparty/grpc/grpc-build/grpc_cpp_plugin" hello.proto
+
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-milvus hello.proto
+
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc="../../cmake-build-debug/thirdparty/grpc/grpc-build/grpc_cpp_plugin" master.proto
+
+../../cmake-build-debug/thirdparty/grpc/grpc-build/third_party/protobuf/protoc -I . --cpp_out=./gen-milvus master.proto
\ No newline at end of file

proxy/src/grpc/gen-milvus/hello.grpc.pb.cc

+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: hello.proto
+
+#include "hello.pb.h"
+#include "hello.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace milvus {
+namespace grpc {
+
+static const char* HelloService_method_names[] = {
+  "/milvus.grpc.HelloService/SayHello",
+};
+
+std::unique_ptr< HelloService::Stub> HelloService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< HelloService::Stub> stub(new HelloService::Stub(channel));
+  return stub;
+}
+
+HelloService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
+  : channel_(channel), rpcmethod_SayHello_(HelloService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status HelloService::Stub::SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::milvus::grpc::HelloReply* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_SayHello_, context, request, response);
+}
+
+void HelloService::Stub::experimental_async::SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SayHello_, context, request, response, std::move(f));
+}
+
+void HelloService::Stub::experimental_async::SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SayHello_, context, request, response, std::move(f));
+}
+
+void HelloService::Stub::experimental_async::SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SayHello_, context, request, response, reactor);
+}
+
+void HelloService::Stub::experimental_async::SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SayHello_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>* HelloService::Stub::AsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HelloReply>::Create(channel_.get(), cq, rpcmethod_SayHello_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>* HelloService::Stub::PrepareAsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HelloReply>::Create(channel_.get(), cq, rpcmethod_SayHello_, context, request, false);
+}
+
+HelloService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      HelloService_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< HelloService::Service, ::milvus::grpc::HelloRequest, ::milvus::grpc::HelloReply>(
+          std::mem_fn(&HelloService::Service::SayHello), this)));
+}
+
+HelloService::Service::~Service() {
+}
+
+::grpc::Status HelloService::Service::SayHello(::grpc::ServerContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace milvus
+}  // namespace grpc
+

proxy/src/grpc/gen-milvus/hello.grpc.pb.h

+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: hello.proto
+#ifndef GRPC_hello_2eproto__INCLUDED
+#define GRPC_hello_2eproto__INCLUDED
+
+#include "hello.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc_impl {
+class CompletionQueue;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
+}  // namespace grpc
+
+namespace milvus {
+namespace grpc {
+
+class HelloService final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "milvus.grpc.HelloService";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::milvus::grpc::HelloReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>> AsyncSayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>>(AsyncSayHelloRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>> PrepareAsyncSayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>>(PrepareAsyncSayHelloRaw(context, request, cq));
+    }
+    class experimental_async_interface {
+     public:
+      virtual ~experimental_async_interface() {}
+      virtual void SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+    };
+    virtual class experimental_async_interface* experimental_async() { return nullptr; }
+  private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>* AsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HelloReply>* PrepareAsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    ::grpc::Status SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::milvus::grpc::HelloReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>> AsyncSayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>>(AsyncSayHelloRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>> PrepareAsyncSayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>>(PrepareAsyncSayHelloRaw(context, request, cq));
+    }
+    class experimental_async final :
+      public StubInterface::experimental_async_interface {
+     public:
+      void SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)>) override;
+      void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, std::function<void(::grpc::Status)>) override;
+      void SayHello(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+     private:
+      friend class Stub;
+      explicit experimental_async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class experimental_async_interface* experimental_async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_{this};
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>* AsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HelloReply>* PrepareAsyncSayHelloRaw(::grpc::ClientContext* context, const ::milvus::grpc::HelloRequest& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_SayHello_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    virtual ::grpc::Status SayHello(::grpc::ServerContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_SayHello() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSayHello(::grpc::ServerContext* context, ::milvus::grpc::HelloRequest* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HelloReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_SayHello<Service > AsyncService;
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_SayHello() {
+      ::grpc::Service::experimental().MarkMethodCallback(0,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HelloRequest, ::milvus::grpc::HelloReply>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::HelloRequest* request,
+                 ::milvus::grpc::HelloReply* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->SayHello(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_SayHello(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::HelloRequest, ::milvus::grpc::HelloReply>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HelloRequest, ::milvus::grpc::HelloReply>*>(
+          ::grpc::Service::experimental().GetHandler(0))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  typedef ExperimentalWithCallbackMethod_SayHello<Service > ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_SayHello() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_SayHello() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSayHello(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_SayHello() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(0,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->SayHello(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void SayHello(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_SayHello : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_SayHello() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HelloRequest, ::milvus::grpc::HelloReply>(std::bind(&WithStreamedUnaryMethod_SayHello<BaseClass>::StreamedSayHello, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_SayHello() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status SayHello(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HelloRequest* /*request*/, ::milvus::grpc::HelloReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedSayHello(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HelloRequest,::milvus::grpc::HelloReply>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_SayHello<Service > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_SayHello<Service > StreamedService;
+};
+
+}  // namespace grpc
+}  // namespace milvus
+
+
+#endif  // GRPC_hello_2eproto__INCLUDED

proxy/src/grpc/gen-milvus/hello.pb.h

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: hello.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_hello_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_hello_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3009000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_hello_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_hello_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    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[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_hello_2eproto;
+namespace milvus {
+namespace grpc {
+class HelloReply;
+class HelloReplyDefaultTypeInternal;
+extern HelloReplyDefaultTypeInternal _HelloReply_default_instance_;
+class HelloRequest;
+class HelloRequestDefaultTypeInternal;
+extern HelloRequestDefaultTypeInternal _HelloRequest_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> ::milvus::grpc::HelloReply* Arena::CreateMaybeMessage<::milvus::grpc::HelloReply>(Arena*);
+template<> ::milvus::grpc::HelloRequest* Arena::CreateMaybeMessage<::milvus::grpc::HelloRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace milvus {
+namespace grpc {
+
+// ===================================================================
+
+class HelloRequest :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HelloRequest) */ {
+ public:
+  HelloRequest();
+  virtual ~HelloRequest();
+
+  HelloRequest(const HelloRequest& from);
+  HelloRequest(HelloRequest&& from) noexcept
+    : HelloRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline HelloRequest& operator=(const HelloRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HelloRequest& operator=(HelloRequest&& 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 HelloRequest& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const HelloRequest* internal_default_instance() {
+    return reinterpret_cast<const HelloRequest*>(
+               &_HelloRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(HelloRequest& a, HelloRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HelloRequest* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline HelloRequest* New() const final {
+    return CreateMaybeMessage<HelloRequest>(nullptr);
+  }
+
+  HelloRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<HelloRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const HelloRequest& from);
+  void MergeFrom(const HelloRequest& 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(HelloRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.HelloRequest";
+  }
+  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_hello_2eproto);
+    return ::descriptor_table_hello_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  void set_name(const std::string& value);
+  void set_name(std::string&& value);
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  std::string* mutable_name();
+  std::string* release_name();
+  void set_allocated_name(std::string* name);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.HelloRequest)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_hello_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HelloReply :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HelloReply) */ {
+ public:
+  HelloReply();
+  virtual ~HelloReply();
+
+  HelloReply(const HelloReply& from);
+  HelloReply(HelloReply&& from) noexcept
+    : HelloReply() {
+    *this = ::std::move(from);
+  }
+
+  inline HelloReply& operator=(const HelloReply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HelloReply& operator=(HelloReply&& 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 HelloReply& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const HelloReply* internal_default_instance() {
+    return reinterpret_cast<const HelloReply*>(
+               &_HelloReply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(HelloReply& a, HelloReply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HelloReply* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline HelloReply* New() const final {
+    return CreateMaybeMessage<HelloReply>(nullptr);
+  }
+
+  HelloReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<HelloReply>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const HelloReply& from);
+  void MergeFrom(const HelloReply& 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(HelloReply* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.HelloReply";
+  }
+  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_hello_2eproto);
+    return ::descriptor_table_hello_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMsgFieldNumber = 1,
+  };
+  // string msg = 1;
+  void clear_msg();
+  const std::string& msg() const;
+  void set_msg(const std::string& value);
+  void set_msg(std::string&& value);
+  void set_msg(const char* value);
+  void set_msg(const char* value, size_t size);
+  std::string* mutable_msg();
+  std::string* release_msg();
+  void set_allocated_msg(std::string* msg);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.HelloReply)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_hello_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// HelloRequest
+
+// string name = 1;
+inline void HelloRequest::clear_name() {
+  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& HelloRequest::name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.HelloRequest.name)
+  return name_.GetNoArena();
+}
+inline void HelloRequest::set_name(const std::string& value) {
+  
+  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.HelloRequest.name)
+}
+inline void HelloRequest::set_name(std::string&& value) {
+  
+  name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HelloRequest.name)
+}
+inline void HelloRequest::set_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.HelloRequest.name)
+}
+inline void HelloRequest::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HelloRequest.name)
+}
+inline std::string* HelloRequest::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.HelloRequest.name)
+  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* HelloRequest::release_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.HelloRequest.name)
+  
+  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void HelloRequest::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HelloRequest.name)
+}
+
+// -------------------------------------------------------------------
+
+// HelloReply
+
+// string msg = 1;
+inline void HelloReply::clear_msg() {
+  msg_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& HelloReply::msg() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.HelloReply.msg)
+  return msg_.GetNoArena();
+}
+inline void HelloReply::set_msg(const std::string& value) {
+  
+  msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.HelloReply.msg)
+}
+inline void HelloReply::set_msg(std::string&& value) {
+  
+  msg_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HelloReply.msg)
+}
+inline void HelloReply::set_msg(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.HelloReply.msg)
+}
+inline void HelloReply::set_msg(const char* value, size_t size) {
+  
+  msg_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HelloReply.msg)
+}
+inline std::string* HelloReply::mutable_msg() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.HelloReply.msg)
+  return msg_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* HelloReply::release_msg() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.HelloReply.msg)
+  
+  return msg_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void HelloReply::set_allocated_msg(std::string* msg) {
+  if (msg != nullptr) {
+    
+  } else {
+    
+  }
+  msg_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HelloReply.msg)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace grpc
+}  // namespace milvus
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_hello_2eproto

proxy/src/grpc/gen-milvus/master.grpc.pb.cc

+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: master.proto
+
+#include "master.pb.h"
+#include "master.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace master {
+
+static const char* Greeter_method_names[] = {
+  "/master.Greeter/ReportAddress",
+  "/master.Greeter/GetAddress",
+};
+
+std::unique_ptr< Greeter::Stub> Greeter::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< Greeter::Stub> stub(new Greeter::Stub(channel));
+  return stub;
+}
+
+Greeter::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
+  : channel_(channel), rpcmethod_ReportAddress_(Greeter_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_GetAddress_(Greeter_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status Greeter::Stub::ReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::master::Reply* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ReportAddress_, context, request, response);
+}
+
+void Greeter::Stub::experimental_async::ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReportAddress_, context, request, response, std::move(f));
+}
+
+void Greeter::Stub::experimental_async::ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReportAddress_, context, request, response, std::move(f));
+}
+
+void Greeter::Stub::experimental_async::ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReportAddress_, context, request, response, reactor);
+}
+
+void Greeter::Stub::experimental_async::ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReportAddress_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::master::Reply>* Greeter::Stub::AsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::master::Reply>::Create(channel_.get(), cq, rpcmethod_ReportAddress_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::master::Reply>* Greeter::Stub::PrepareAsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::master::Reply>::Create(channel_.get(), cq, rpcmethod_ReportAddress_, context, request, false);
+}
+
+::grpc::Status Greeter::Stub::GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::master::Request* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetAddress_, context, request, response);
+}
+
+void Greeter::Stub::experimental_async::GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetAddress_, context, request, response, std::move(f));
+}
+
+void Greeter::Stub::experimental_async::GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetAddress_, context, request, response, std::move(f));
+}
+
+void Greeter::Stub::experimental_async::GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetAddress_, context, request, response, reactor);
+}
+
+void Greeter::Stub::experimental_async::GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetAddress_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::master::Request>* Greeter::Stub::AsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::master::Request>::Create(channel_.get(), cq, rpcmethod_GetAddress_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::master::Request>* Greeter::Stub::PrepareAsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::master::Request>::Create(channel_.get(), cq, rpcmethod_GetAddress_, context, request, false);
+}
+
+Greeter::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      Greeter_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< Greeter::Service, ::master::Request, ::master::Reply>(
+          std::mem_fn(&Greeter::Service::ReportAddress), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      Greeter_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< Greeter::Service, ::master::EmptyRequest, ::master::Request>(
+          std::mem_fn(&Greeter::Service::GetAddress), this)));
+}
+
+Greeter::Service::~Service() {
+}
+
+::grpc::Status Greeter::Service::ReportAddress(::grpc::ServerContext* context, const ::master::Request* request, ::master::Reply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status Greeter::Service::GetAddress(::grpc::ServerContext* context, const ::master::EmptyRequest* request, ::master::Request* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace master
+

proxy/src/grpc/gen-milvus/master.pb.h

+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: master.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_master_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_master_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3009000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_master_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_master_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    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[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_master_2eproto;
+namespace master {
+class EmptyRequest;
+class EmptyRequestDefaultTypeInternal;
+extern EmptyRequestDefaultTypeInternal _EmptyRequest_default_instance_;
+class Reply;
+class ReplyDefaultTypeInternal;
+extern ReplyDefaultTypeInternal _Reply_default_instance_;
+class Request;
+class RequestDefaultTypeInternal;
+extern RequestDefaultTypeInternal _Request_default_instance_;
+}  // namespace master
+PROTOBUF_NAMESPACE_OPEN
+template<> ::master::EmptyRequest* Arena::CreateMaybeMessage<::master::EmptyRequest>(Arena*);
+template<> ::master::Reply* Arena::CreateMaybeMessage<::master::Reply>(Arena*);
+template<> ::master::Request* Arena::CreateMaybeMessage<::master::Request>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace master {
+
+// ===================================================================
+
+class Request :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:master.Request) */ {
+ public:
+  Request();
+  virtual ~Request();
+
+  Request(const Request& from);
+  Request(Request&& from) noexcept
+    : Request() {
+    *this = ::std::move(from);
+  }
+
+  inline Request& operator=(const Request& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Request& operator=(Request&& 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 Request& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Request* internal_default_instance() {
+    return reinterpret_cast<const Request*>(
+               &_Request_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Request& a, Request& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Request* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Request* New() const final {
+    return CreateMaybeMessage<Request>(nullptr);
+  }
+
+  Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Request>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Request& from);
+  void MergeFrom(const Request& 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(Request* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "master.Request";
+  }
+  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_master_2eproto);
+    return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAddressFieldNumber = 1,
+  };
+  // string address = 1;
+  void clear_address();
+  const std::string& address() const;
+  void set_address(const std::string& value);
+  void set_address(std::string&& value);
+  void set_address(const char* value);
+  void set_address(const char* value, size_t size);
+  std::string* mutable_address();
+  std::string* release_address();
+  void set_allocated_address(std::string* address);
+
+  // @@protoc_insertion_point(class_scope:master.Request)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_master_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EmptyRequest :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:master.EmptyRequest) */ {
+ public:
+  EmptyRequest();
+  virtual ~EmptyRequest();
+
+  EmptyRequest(const EmptyRequest& from);
+  EmptyRequest(EmptyRequest&& from) noexcept
+    : EmptyRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline EmptyRequest& operator=(const EmptyRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EmptyRequest& operator=(EmptyRequest&& 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 EmptyRequest& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EmptyRequest* internal_default_instance() {
+    return reinterpret_cast<const EmptyRequest*>(
+               &_EmptyRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(EmptyRequest& a, EmptyRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EmptyRequest* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EmptyRequest* New() const final {
+    return CreateMaybeMessage<EmptyRequest>(nullptr);
+  }
+
+  EmptyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<EmptyRequest>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const EmptyRequest& from);
+  void MergeFrom(const EmptyRequest& 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(EmptyRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "master.EmptyRequest";
+  }
+  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_master_2eproto);
+    return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:master.EmptyRequest)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_master_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Reply :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:master.Reply) */ {
+ public:
+  Reply();
+  virtual ~Reply();
+
+  Reply(const Reply& from);
+  Reply(Reply&& from) noexcept
+    : Reply() {
+    *this = ::std::move(from);
+  }
+
+  inline Reply& operator=(const Reply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Reply& operator=(Reply&& 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 Reply& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Reply* internal_default_instance() {
+    return reinterpret_cast<const Reply*>(
+               &_Reply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Reply& a, Reply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Reply* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Reply* New() const final {
+    return CreateMaybeMessage<Reply>(nullptr);
+  }
+
+  Reply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Reply>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Reply& from);
+  void MergeFrom(const Reply& 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(Reply* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "master.Reply";
+  }
+  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_master_2eproto);
+    return ::descriptor_table_master_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStatusFieldNumber = 1,
+  };
+  // bool status = 1;
+  void clear_status();
+  bool status() const;
+  void set_status(bool value);
+
+  // @@protoc_insertion_point(class_scope:master.Reply)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  bool status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_master_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Request
+
+// string address = 1;
+inline void Request::clear_address() {
+  address_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Request::address() const {
+  // @@protoc_insertion_point(field_get:master.Request.address)
+  return address_.GetNoArena();
+}
+inline void Request::set_address(const std::string& value) {
+  
+  address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:master.Request.address)
+}
+inline void Request::set_address(std::string&& value) {
+  
+  address_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:master.Request.address)
+}
+inline void Request::set_address(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:master.Request.address)
+}
+inline void Request::set_address(const char* value, size_t size) {
+  
+  address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:master.Request.address)
+}
+inline std::string* Request::mutable_address() {
+  
+  // @@protoc_insertion_point(field_mutable:master.Request.address)
+  return address_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Request::release_address() {
+  // @@protoc_insertion_point(field_release:master.Request.address)
+  
+  return address_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Request::set_allocated_address(std::string* address) {
+  if (address != nullptr) {
+    
+  } else {
+    
+  }
+  address_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), address);
+  // @@protoc_insertion_point(field_set_allocated:master.Request.address)
+}
+
+// -------------------------------------------------------------------
+
+// EmptyRequest
+
+// -------------------------------------------------------------------
+
+// Reply
+
+// bool status = 1;
+inline void Reply::clear_status() {
+  status_ = false;
+}
+inline bool Reply::status() const {
+  // @@protoc_insertion_point(field_get:master.Reply.status)
+  return status_;
+}
+inline void Reply::set_status(bool value) {
+  
+  status_ = value;
+  // @@protoc_insertion_point(field_set:master.Reply.status)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace master
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_master_2eproto

proxy/src/grpc/hello.proto

+syntax = "proto3";
+
+package milvus.grpc;
+
+message HelloRequest{
+string name = 1;
+}
+
+message HelloReply{
+string msg = 1;
+}
+
+service HelloService{
+    rpc SayHello (HelloRequest) returns (HelloReply){}
+}
\ No newline at end of file

proxy/src/grpc/master.proto

+syntax = "proto3";
+
+package master;
+
+// The greeting service definition.
+service Greeter {
+  // receive a grpc_server address and set to etcd.
+  rpc ReportAddress (Request) returns (Reply) {}
+
+  // send a grpc_server address to client
+  rpc GetAddress (EmptyRequest) returns (Request) {}
+}
+
+// The request message containing the user's name.
+message Request {
+  string address = 1;
+}
+
+message EmptyRequest {
+
+}
+
+// The response message containing the greetings
+message Reply {
+  bool status = 1;
+}
\ No newline at end of file

proxy/src/server/CMakeLists.txt

@@ -15,6 +15,10 @@ set( GRPC_SERVICE_FILES ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc
                         ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.pb.cc
                         ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.grpc.pb.cc
                         ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc
+                        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/hello.grpc.pb.cc
+                        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/hello.pb.cc
+                        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/master.grpc.pb.cc
+                        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/master.pb.cc
                         )
 
 aux_source_directory( ${MILVUS_ENGINE_SRC}/server                   SERVER_SERVICE_FILES )

proxy/src/server/grpc_impl/GrpcServer.cpp

@@ -33,7 +33,8 @@
 
 #include "GrpcRequestHandler.h"
 #include "config/ServerConfig.h"
-#include "grpc/gen-milvus/milvus.grpc.pb.h"
+#include "server/hello/HelloService.h"
+#include "server/hello/ReportAddress.h"
 // #include "server/DBWrapper.h"
 #include "server/grpc_impl/interceptor/SpanInterceptor.h"
 #include "utils/Log.h"
@@ -96,6 +97,17 @@ GrpcServer::StartService() {
     builder.AddListeningPort(server_address, ::grpc::InsecureServerCredentials());
     builder.RegisterService(&service);
 
+    HelloService helloService;
+    builder.RegisterService(&helloService);
+    // report address to mmaster
+    auto reportClient = new ReportClient(::grpc::CreateChannel("192.168.2.28:50051",
+                                                             ::grpc::InsecureChannelCredentials()));
+    auto status = reportClient->ReportAddress();
+    delete(reportClient);
+    if (!status.ok()){
+        return Status(milvus::DB_ERROR, "");
+    }
+
     // Add gRPC interceptor
     using InterceptorI = ::grpc::experimental::ServerInterceptorFactoryInterface;
     using InterceptorIPtr = std::unique_ptr<InterceptorI>;

proxy/src/server/hello/HelloService.h

+#ifndef MILVUS_HELLOSERVICE_H
+#define MILVUS_HELLOSERVICE_H
+
+#include "grpc++/grpc++.h"
+#include <src/grpc/gen-milvus/hello.grpc.pb.h>
+
+class HelloService final : public ::milvus::grpc::HelloService::Service{
+    ::grpc::Status SayHello
+            (::grpc::ServerContext* context, const ::milvus::grpc::HelloRequest* request, ::milvus::grpc::HelloReply* response){
+        const auto& name = request->name();
+        response->mutable_msg()->append( "hello " +  name);
+        return ::grpc::Status::OK;
+    }
+};
+
+
+#endif //MILVUS_HELLOSERVICE_H

proxy/src/server/hello/ReportAddress.h

+#pragma once
+
+#include "grpc++/grpc++.h"
+#include "src/grpc/gen-milvus/master.grpc.pb.h"
+
+class ReportClient {
+public:
+    ReportClient(const std::shared_ptr<::grpc::ChannelInterface>& channel)
+            : stub_(master::Greeter::NewStub(channel)) {}
+
+    milvus::Status
+    ReportAddress(){
+        grpc::ClientContext context;
+        master::Request req;
+        master::Reply rsp;
+
+        req.set_address("192.168.2.18:19530");
+        auto status =  stub_->ReportAddress(&context, req, &rsp);
+        if (status.ok() && rsp.status()){
+            std::cout << "Report address to master Succeed" << std::endl;
+            return milvus::Status::OK();
+        } else{
+            std::cout << "Error occur when report address to master " << status.error_message() << std::endl;
+            return milvus::Status(milvus::SERVER_ERROR_CODE_BASE, "");
+        }
+    }
+
+private:
+    std::unique_ptr<master::Greeter::Stub> stub_;
+};
\ No newline at end of file

proxy/src/version.h

@@ -11,5 +11,5 @@
 
 #define MILVUS_VERSION "0.10.0"
 #define BUILD_TYPE "Debug"
-#define BUILD_TIME "2020-08-26 19:22.49"
-#define LAST_COMMIT_ID "2a5c8e152bc9dbc0653aa4aae2c712b59661bf58"
+#define BUILD_TIME "2020-08-28 11:25.21"
+#define LAST_COMMIT_ID "ed93e96c6aa3050312a0b7950f04a1193e36bd10"

proxy/thirdparty/CMakeLists.txt

@@ -55,5 +55,5 @@ endif()
 
 # ****************************** Thirdparty pulsar-client-cpp ***************************************
 if ( MILVUS_WITH_PULSAR )
-    include(pulsar-client-cpp/CMakeLists.txt)
+    add_subdirectory(pulsar)
 endif()
\ No newline at end of file

proxy/thirdparty/pulsar/CMakeLists

+### This file is copyed from pulsar, and deleted add custom target "format".
+
+cmake_minimum_required(VERSION 3.4)
+project (pulsar-cpp)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake_modules")
+
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    set(CMAKE_CXX_COMPILER_LAUNCHER "ccache")
+    MESSAGE(STATUS "Using CCache")
+endif(CCACHE_PROGRAM)
+
+MESSAGE(STATUS "ARCHITECTURE: ${CMAKE_SYSTEM_PROCESSOR}")
+
+option(BUILD_TESTS "Build tests" ON)
+MESSAGE(STATUS "BUILD_TESTS:  " ${BUILD_TESTS})
+
+option(BUILD_PYTHON_WRAPPER "Build Pulsar Python wrapper" ON)
+MESSAGE(STATUS "BUILD_PYTHON_WRAPPER:  " ${BUILD_PYTHON_WRAPPER})
+
+option(LINK_STATIC "Link against static libraries" OFF)
+MESSAGE(STATUS "LINK_STATIC:  " ${LINK_STATIC})
+
+option(USE_LOG4CXX "Build with Log4cxx support" OFF)
+MESSAGE(STATUS "USE_LOG4CXX:  " ${USE_LOG4CXX})
+
+IF (CMAKE_BUILD_TYPE STREQUAL "")
+    set(CMAKE_BUILD_TYPE RelWithDebInfo)
+ENDIF ()
+
+MESSAGE(STATUS "CMAKE_BUILD_TYPE:  " ${CMAKE_BUILD_TYPE})
+
+set(Boost_NO_BOOST_CMAKE ON)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_C_STANDARD 11)
+
+if (MSVC)
+    # Visual Studio compiler flags
+    add_definitions(-DWIN32_LEAN_AND_MEAN -DNOGDI -D_WIN32_WINNT=0x0501 -D_CRT_SECURE_NO_WARNINGS)
+    add_compile_options(/wd4244 /wd4267 /wd4018 /wd4715 /wd4251 /wd4275)
+else()
+    add_compile_options(-Werror=switch -Wno-deprecated-declarations)
+    if (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+        add_compile_options(-msse4.2 -mpclmul)
+    endif()
+endif(MSVC)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(Protobuf_LITE_LIBRARIES $ENV{PROTOBUF_LIBRARIES})
+set(LOG_CATEGORY_NAME $ENV{LOG_CATEGORY_NAME})
+
+if (NOT LOG_CATEGORY_NAME)
+    set(LOG_CATEGORY_NAME "\"pulsar.\"")
+endif(NOT LOG_CATEGORY_NAME)
+
+add_definitions(-DLOG_CATEGORY_NAME=${LOG_CATEGORY_NAME} -DBUILDING_PULSAR -DBOOST_ALL_NO_LIB -DBOOST_ALLOW_DEPRECATED_HEADERS)
+
+### This part is to find and keep SSL dynamic libs in RECORD_OPENSSL_SSL_LIBRARY and RECORD_OPENSSL_CRYPTO_LIBRARY
+### After find the libs, will unset related cache, and will not affact another same call to find_package.
+if (APPLE)
+    set(OPENSSL_INCLUDE_DIR /usr/local/opt/openssl/include/)
+    set(OPENSSL_ROOT_DIR /usr/local/opt/openssl/)
+endif ()
+
+set(OPENSSL_ROOT_DIR /usr/lib64/)
+set(OPENSSL_USE_STATIC_LIBS FALSE)
+find_package(OpenSSL REQUIRED)
+set(RECORD_OPENSSL_SSL_LIBRARY ${OPENSSL_SSL_LIBRARY})
+set(RECORD_OPENSSL_CRYPTO_LIBRARY ${OPENSSL_CRYPTO_LIBRARY})
+
+unset(OPENSSL_FOUND CACHE)
+unset(OPENSSL_INCLUDE_DIR CACHE)
+unset(OPENSSL_CRYPTO_LIBRARY CACHE)
+unset(OPENSSL_CRYPTO_LIBRARIES CACHE)
+unset(OPENSSL_SSL_LIBRARY CACHE)
+unset(OPENSSL_SSL_LIBRARIES CACHE)
+unset(OPENSSL_LIBRARIES CACHE)
+unset(OPENSSL_VERSION CACHE)
+
+if (LINK_STATIC)
+    find_library(ZLIB_LIBRARIES REQUIRED NAMES libz.a z zlib)
+    find_library(Protobuf_LITE_LIBRARIES NAMES libprotobuf-lite.a libprotobuf-lite)
+    find_library(CURL_LIBRARIES NAMES libcurl.a curl curl_a libcurl_a)
+    find_library(LIB_ZSTD NAMES libzstd.a)
+    find_library(LIB_SNAPPY NAMES libsnappy.a)
+
+    if (USE_LOG4CXX)
+        if (LOG4CXX_USE_DYNAMIC_LIBS)
+            find_library(LOG4CXX_LIBRARY_PATH log4cxx)
+        else ()
+            find_library(LOG4CXX_LIBRARY_PATH NAMES liblog4cxx.a)
+
+            # Libraries needed by log4cxx to link statically with
+            find_library(APR_LIBRARY_PATH NAMES libapr-1 PATHS /usr/lib /usr/local/apr/lib /usr/local/opt/apr/libexec/lib/)
+            find_library(APR_UTIL_LIBRARY_PATH NAMES libaprutil-1 PATHS /usr/lib /usr/local/apr/lib /usr/local/opt/apr-util/libexec/lib/)
+            find_library(EXPAT_LIBRARY_PATH NAMES libexpat expat)
+            if (APPLE)
+                find_library(ICONV_LIBRARY_PATH NAMES libiconv iconv)
+            else ()
+                set(ICONV_LIBRARY_PATH )
+            endif (APPLE)
+        endif (LOG4CXX_USE_DYNAMIC_LIBS)
+    endif (USE_LOG4CXX)
+
+    if (MSVC)
+        add_definitions(-DCURL_STATICLIB)
+    endif()
+
+    if (UNIX AND NOT APPLE)
+        set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+    endif()
+
+    SET(Boost_USE_STATIC_LIBS   ON)
+    SET(OPENSSL_USE_STATIC_LIBS TRUE)
+else()
+    # Link to shared libraries
+    find_package(ZLIB REQUIRED)
+    set(ZLIB_LIBRARIES ${ZLIB_LIBRARIES})
+    if (NOT PROTOBUF_LIBRARIES)
+        find_package(ProtoBuf QUIET)
+        if (NOT Protobuf_FOUND OR NOT Protobuf_LITE_LIBRARIES)
+            find_library(Protobuf_LITE_LIBRARIES protobuf-lite libprotobuf-lite)
+            find_path(Protobuf_INCLUDE_DIRS google/protobuf/stubs/common.h)
+        endif()
+    endif (NOT PROTOBUF_LIBRARIES)
+
+    find_library(LIB_ZSTD zstd)
+    find_library(LIB_SNAPPY NAMES snappy libsnappy)
+    find_library(CURL_LIBRARIES NAMES curl libcurl)
+
+    if (USE_LOG4CXX)
+        find_library(LOG4CXX_LIBRARY_PATH log4cxx)
+        find_path(LOG4CXX_INCLUDE_PATH log4cxx/logger.h)
+    endif (USE_LOG4CXX)
+endif (LINK_STATIC)
+
+if (MSVC)
+  find_package(Boost REQUIRED COMPONENTS program_options regex system date_time)
+else()
+  find_package(Boost REQUIRED COMPONENTS program_options regex system)
+endif()
+
+if (BUILD_PYTHON_WRAPPER)
+    find_package(PythonLibs REQUIRED)
+    MESSAGE(STATUS "PYTHON: " ${PYTHONLIBS_VERSION_STRING})
+
+    if (PYTHONLIBS_VERSION_STRING MATCHES "^3.+$")
+        MESSAGE(STATUS "DETECTED Python 3")
+        string(REPLACE "." ";" PYTHONLIBS_VERSION_NO_LIST ${PYTHONLIBS_VERSION_STRING})
+        list(GET PYTHONLIBS_VERSION_NO_LIST 0 PYTHONLIBS_VERSION_MAJOR)
+        list(GET PYTHONLIBS_VERSION_NO_LIST 1 PYTHONLIBS_VERSION_MINOR)
+        set(BOOST_PYTHON_NAME_POSTFIX ${PYTHONLIBS_VERSION_MAJOR}${PYTHONLIBS_VERSION_MINOR})
+        # For python3 the lib name is boost_python3
+        set(BOOST_PYTHON_NAME_LIST python36;python37;python38;python3;python3-mt;python-py${BOOST_PYTHON_NAME_POSTFIX};python${BOOST_PYTHON_NAME_POSTFIX}-mt;python${BOOST_PYTHON_NAME_POSTFIX})
+    else ()
+        # Regular boost_python
+        set(BOOST_PYTHON_NAME_LIST python;python-mt;python-py27;python27-mt;python27)
+    endif ()
+
+    foreach (BOOST_PYTHON_NAME IN LISTS BOOST_PYTHON_NAME_LIST)
+        find_package(Boost QUIET COMPONENTS ${BOOST_PYTHON_NAME})
+        if (${Boost_FOUND})
+            set(BOOST_PYTHON_NAME_FOUND ${BOOST_PYTHON_NAME})
+            break()
+        endif()
+    endforeach()
+
+    if (NOT ${Boost_FOUND})
+        MESSAGE(FATAL_ERROR "Could not find Boost Python library")
+    endif ()
+
+    find_package(Boost REQUIRED COMPONENTS ${BOOST_PYTHON_NAME_FOUND})
+endif (BUILD_PYTHON_WRAPPER)
+
+if (APPLE)
+    set(OPENSSL_INCLUDE_DIR /usr/local/opt/openssl/include/)
+    set(OPENSSL_ROOT_DIR /usr/local/opt/openssl/)
+endif ()
+
+find_package(OpenSSL REQUIRED)
+
+if (BUILD_TESTS)
+    find_path(GTEST_INCLUDE_PATH gtest/gtest.h)
+    find_path(GMOCK_INCLUDE_PATH gmock/gmock.h)
+endif ()
+
+if (USE_LOG4CXX)
+    set(CMAKE_CXX_FLAGS " -DUSE_LOG4CXX ${CMAKE_CXX_FLAGS}")
+    find_path(LOG4CXX_INCLUDE_PATH log4cxx/logger.h)
+endif (USE_LOG4CXX)
+
+if (NOT APPLE AND NOT MSVC)
+    # we don't set options below to build _pulsar.so
+    set(CMAKE_CXX_FLAGS_PYTHON "${CMAKE_CXX_FLAGS}")
+    # Hide all non-exported symbols to avoid conflicts
+    add_compile_options(-fvisibility=hidden -Wl,--exclude-libs,ALL)
+endif ()
+
+if (LIB_ZSTD)
+    set(HAS_ZSTD 1)
+else ()
+    set(HAS_ZSTD 0)
+endif ()
+MESSAGE(STATUS "HAS_ZSTD: ${HAS_ZSTD}")
+
+if (LIB_SNAPPY)
+    set(HAS_SNAPPY 1)
+else ()
+    set(HAS_SNAPPY 0)
+endif ()
+MESSAGE(STATUS "HAS_SNAPPY: ${HAS_SNAPPY}")
+
+set(ADDITIONAL_LIBRARIES $ENV{PULSAR_ADDITIONAL_LIBRARIES})
+link_directories( $ENV{PULSAR_ADDITIONAL_LIBRARY_PATH} )
+
+set(AUTOGEN_DIR ${CMAKE_BINARY_DIR}/generated)
+file(MAKE_DIRECTORY ${AUTOGEN_DIR})
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}/include
+  ${AUTOGEN_DIR}
+  ${Boost_INCLUDE_DIR}
+  ${OPENSSL_INCLUDE_DIR}
+  ${ZLIB_INCLUDE_DIRS}
+  ${CURL_INCLUDE_DIRS}
+  ${Protobuf_INCLUDE_DIRS}
+  ${LOG4CXX_INCLUDE_PATH}
+  ${GTEST_INCLUDE_PATH}
+  ${GMOCK_INCLUDE_PATH}
+)
+
+set(COMMON_LIBS
+  ${COMMON_LIBS}
+  ${Boost_REGEX_LIBRARY}
+  ${Boost_SYSTEM_LIBRARY}
+  ${CURL_LIBRARIES}
+  ${OPENSSL_LIBRARIES}
+  ${ZLIB_LIBRARIES}
+  ${Protobuf_LITE_LIBRARIES}
+  ${ADDITIONAL_LIBRARIES}
+)
+
+if (MSVC)
+  set(COMMON_LIBS
+    ${COMMON_LIBS}
+    ${Boost_DATE_TIME_LIBRARY}
+  )
+endif()
+
+if (NOT MSVC)
+    set(COMMON_LIBS
+    ${COMMON_LIBS} -lpthread -lm
+    dl
+    pthread
+    )
+else()
+    set(COMMON_LIBS
+    ${COMMON_LIBS}
+    wldap32.lib
+    Normaliz.lib)
+endif()
+
+if (USE_LOG4CXX)
+    set(COMMON_LIBS
+      ${COMMON_LIBS}
+      ${LOG4CXX_LIBRARY_PATH}
+      ${APR_LIBRARY_PATH}
+      ${APR_UTIL_LIBRARY_PATH}
+      ${EXPAT_LIBRARY_PATH}
+      ${ICONV_LIBRARY_PATH}
+    )
+endif ()
+
+if (HAS_ZSTD)
+    set(COMMON_LIBS ${COMMON_LIBS} ${LIB_ZSTD} )
+endif ()
+
+add_definitions(-DHAS_ZSTD=${HAS_ZSTD})
+
+if (HAS_SNAPPY)
+    set(COMMON_LIBS ${COMMON_LIBS} ${LIB_SNAPPY} )
+endif ()
+
+add_definitions(-DHAS_SNAPPY=${HAS_SNAPPY})
+
+if(NOT APPLE AND NOT MSVC)
+    set(COMMON_LIBS ${COMMON_LIBS} rt)
+endif ()
+
+link_directories(${CMAKE_BINARY_DIR}/lib)
+
+set(LIB_NAME $ENV{PULSAR_LIBRARY_NAME})
+if (NOT LIB_NAME)
+    set(LIB_NAME pulsar)
+endif(NOT LIB_NAME)
+
+set(CLIENT_LIBS
+  ${COMMON_LIBS}
+  ${LIB_NAME}
+)
+
+add_subdirectory(lib)
+add_subdirectory(perf)
+add_subdirectory(examples)
+
+if (BUILD_TESTS)
+    add_subdirectory(tests)
+endif()
+
+if (BUILD_PYTHON_WRAPPER)
+    add_subdirectory(python)
+endif ()
\ No newline at end of file

proxy/thirdparty/pulsar-client-cpp/CMakeLists.txt → proxy/thirdparty/pulsar/CMakeLists.txt

@@ -18,40 +18,51 @@ else ()
             "https://github.com/apache/pulsar/archive/${PULSAR_CLIENT_CPP_VERSION}.zip")
 endif ()
 
+
 message(STATUS "Building pulsar-client-cpp-${PULSAR_CLIENT_CPP_VERSION} from source")
 
-include(ExternalProject)
-ExternalProject_Add(
-        pulsar
-        URL ${PULSAR_URL}
-        PREFIX ${pulsar_ROOT}
-        CONFIGURE_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && cmake -DBUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=${pulsar_ROOT}/build .
-        BUILD_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && make -j8
-        BUILD_IN_SOURCE true
-        INSTALL_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && make install
-)
-#FetchContent_Declare(
+#include(ExternalProject)
+#ExternalProject_Add(
 #        pulsar
 #        URL ${PULSAR_URL}
-#        #        URL_MD5 "f9137c5bc18b7d74027936f0f1bfa5c8"
-#        DOWNLOAD_DIR ${MILVUS_BINARY_DIR}/3rdparty_download/download
-#        SOURCE_DIR  ${CMAKE_CURRENT_BINARY_DIR}/pulsar-client-cpp-src
-#        BINARY_DIR  ${CMAKE_CURRENT_BINARY_DIR}/pulsar-client-cpp-build
+#        PREFIX ${pulsar_ROOT}
+#        CONFIGURE_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && cmake -DBUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=${pulsar_ROOT}/build .
+#        BUILD_COMMAND  cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && cmake .
+#        BUILD_IN_SOURCE true
+#        INSTALL_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && make install
 #)
-#
-#include(FetchContent)
-#FetchContent_GetProperties( pulsar )
-#SET(BUILD_TESTS CACHE BOOL OFF FORCE)
-#if (NOT pulsar_POPULATED)
-#    FetchContent_Populate(pulsar)
-#
-#    # Adding the following targets:
-#    # pulsar-client-cpp
-#    add_subdirectory(${pulsar_SOURCE_DIR}/pulsar-client-cpp
-#            ${pulsar_BINARY_DIR}/pulsar-client-cpp
-#            EXCLUDE_FROM_ALL)
-#endif ()
-#
-#include_directories(${pulsar_SOURCE_DIR}/pulsar-client-cpp/include)
-#get_property(var DIRECTORY "${pulsar_SOURCE_DIR}/pulsar-client-cpp" PROPERTY COMPILE_OPTIONS)
-#message(STATUS "pulsar-client-cpp compile options: ${var}")
+
+
+
+FetchContent_Declare(
+        pulsar
+        URL ${PULSAR_URL}
+        #        URL_MD5 "f9137c5bc18b7d74027936f0f1bfa5c8"
+        DOWNLOAD_DIR ${MILVUS_BINARY_DIR}/3rdparty_download/download
+        SOURCE_DIR  ${CMAKE_CURRENT_BINARY_DIR}/pulsar-src
+        BINARY_DIR  ${CMAKE_CURRENT_BINARY_DIR}/pulsar-build
+)
+
+include(FetchContent)
+FetchContent_GetProperties( pulsar )
+SET(BUILD_TESTS CACHE BOOL OFF FORCE)
+if (NOT pulsar_POPULATED)
+    FetchContent_Populate(pulsar)
+
+    file(REMOVE ${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt)
+    message("${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt")
+    EXECUTE_PROCESS(COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists ${pulsar_SOURCE_DIR}/pulsar-client-cpp/CMakeLists.txt)
+
+    # Adding the following targets:
+    # pulsar-client-cpp
+    add_subdirectory(${pulsar_SOURCE_DIR}/pulsar-client-cpp
+            ${pulsar_BINARY_DIR}
+            EXCLUDE_FROM_ALL)
+
+    target_include_directories(pulsarStatic PUBLIC ${pulsar_SOURCE_DIR}/pulsar-client-cpp/include)
+    target_include_directories(pulsarStatic PUBLIC ${pulsar_SOURCE_DIR}/pulsar-client-cpp)
+    target_include_directories(pulsarStatic PUBLIC ${CMAKE_BINARY_DIR}/thirdparty/grpc/grpc-src/third_party/protobuf/src)
+endif ()
+
+get_property(var DIRECTORY "${pulsar_SOURCE_DIR}/pulsar-client-cpp" PROPERTY COMPILE_OPTIONS)
+message(STATUS "pulsar-client-cpp compile options: ${var}")

storage/internal/tikv/tikv_store.go

@@ -179,19 +179,24 @@ func batchKeys(keys []Key) [][]Key {
 	return batches
 }
 
-func (s *TikvStore) GetRows(ctx context.Context, keys []Key, timestamp Timestamp) ([]Value, error) {
+func (s *TikvStore) GetRows(ctx context.Context, keys []Key, timestamps []Timestamp) ([]Value, error) {
+	if len(keys) != len(timestamps) {
+		return nil, errors.New("the len of keys is not equal to the len of timestamps")
+	}
+
 	batches := batchKeys(keys)
 	ch := make(chan kvPair, len(keys))
 	ctx, cancel := context.WithCancel(ctx)
-	for _, b := range batches {
+	for n, b := range batches {
 		batch := b
+		numBatch := n
 		go func() {
-			for _, key := range batch {
+			for i, key := range batch {
 				select {
 				case <-ctx.Done():
 					return
 				default:
-					v, err := s.GetRow(ctx, key, timestamp)
+					v, err := s.GetRow(ctx, key, timestamps[numBatch*batchSize+i])
 					ch <- kvPair{
 						key:   key,
 						value: v,
@@ -225,14 +230,17 @@ func (s *TikvStore) PutRow(ctx context.Context, key Key, value Value, segment st
 	return s.put(ctx, key, value, timestamp, segment)
 }
 
-func (s *TikvStore) PutRows(ctx context.Context, keys []Key, values []Value, segment string, timestamp Timestamp) error {
+func (s *TikvStore) PutRows(ctx context.Context, keys []Key, values []Value, segment string, timestamps []Timestamp) error {
 	if len(keys) != len(values) {
 		return errors.New("the len of keys is not equal to the len of values")
 	}
+	if len(keys) != len(timestamps) {
+		return errors.New("the len of keys is not equal to the len of timestamps")
+	}
 
 	encodedKeys := make([]Key, len(keys))
 	for i, key := range keys {
-		encodedKeys[i] = EncodeKey(key, timestamp, segment)
+		encodedKeys[i] = EncodeKey(key, timestamps[i], segment)
 	}
 	return s.engine.BatchPut(ctx, encodedKeys, values)
 }
@@ -344,6 +352,31 @@ func (s *TikvStore) DeleteSegmentDL(ctx context.Context, segment string) error {
 	return s.engine.Delete(ctx, EncodeSegment([]byte(segment), SegmentDLMark))
 }
 
+func (s *TikvStore) GetSegments(ctx context.Context, key Key, timestamp Timestamp) ([]string, error) {
+	keys, _, err := s.engine.GetByPrefix(ctx, EncodeDelimiter(key, Delimiter), true)
+	if err != nil {
+		return nil, err
+	}
+	segmentsSet := map[string]bool{}
+	for _, key := range keys {
+		_, ts, segment, err := DecodeKey(key)
+		if err != nil {
+			panic("must no error")
+		}
+		if ts <= timestamp {
+			segmentsSet[segment] = true
+		}
+	}
+
+	var segments []string
+	for k, v := range segmentsSet {
+		if v == true {
+			segments = append(segments, k)
+		}
+	}
+	return segments, err
+}
+
 func (s *TikvStore) Close() error {
 	return s.engine.Close()
 }

storage/internal/tikv/tikv_test.go

@@ -121,7 +121,8 @@ func TestTikvStore_BatchRow(t *testing.T) {
 	size := 0
 	var testKeys []Key
 	var testValues []Value
-	var segments []string
+	var segment = "test"
+	var timestamps []Timestamp
 	for i := 0; size/store.engine.conf.Raw.MaxBatchPutSize < 1; i++ {
 		key := fmt.Sprint("key", i)
 		size += len(key)
@@ -129,18 +130,23 @@ func TestTikvStore_BatchRow(t *testing.T) {
 		value := fmt.Sprint("value", i)
 		size += len(value)
 		testValues = append(testValues, []byte(value))
-		segments = append(segments, "test")
 		v, err := store.GetRow(ctx, Key(key), math.MaxUint64)
 		assert.Nil(t, v)
 		assert.Nil(t, err)
 	}
 
 	// Batch put rows
-	err := store.PutRows(ctx, testKeys, testValues, segments, 1)
+	for range testKeys {
+		timestamps = append(timestamps, 1)
+	}
+	err := store.PutRows(ctx, testKeys, testValues, segment, timestamps)
 	assert.Nil(t, err)
 
 	// Batch get rows
-	checkValues, err := store.GetRows(ctx, testKeys, 2)
+	for i, _ := range timestamps {
+		timestamps[i] = 2
+	}
+	checkValues, err := store.GetRows(ctx, testKeys, timestamps)
 	assert.NotNil(t, checkValues)
 	assert.Nil(t, err)
 	assert.Equal(t, len(checkValues), len(testValues))
@@ -152,7 +158,10 @@ func TestTikvStore_BatchRow(t *testing.T) {
 	err = store.DeleteRows(ctx, testKeys, math.MaxUint64)
 	assert.Nil(t, err)
 	// Ensure all test row is deleted
-	checkValues, err = store.GetRows(ctx, testKeys, math.MaxUint64)
+	for i, _ := range timestamps {
+		timestamps[i] = math.MaxUint64
+	}
+	checkValues, err = store.GetRows(ctx, testKeys, timestamps)
 	assert.Nil(t, err)
 	for _, value := range checkValues {
 		assert.Nil(t, value)
@@ -163,6 +172,33 @@ func TestTikvStore_BatchRow(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestTikvStore_GetSegments(t *testing.T) {
+	ctx := context.Background()
+	key := Key("key")
+
+	// Put rows
+	err := store.PutRow(ctx, key, Value{0}, "a", 1)
+	assert.Nil(t, err)
+	err = store.PutRow(ctx, key, Value{0}, "a", 2)
+	assert.Nil(t, err)
+	err = store.PutRow(ctx, key, Value{0}, "c", 3)
+	assert.Nil(t, err)
+
+	// Get segments
+	segs, err := store.GetSegments(ctx, key, 2)
+	assert.Nil(t, err)
+	assert.Equal(t, 1, len(segs))
+	assert.Equal(t, "a", segs[0])
+
+	segs, err = store.GetSegments(ctx, key, 3)
+	assert.Nil(t, err)
+	assert.Equal(t, 2, len(segs))
+
+	// Clean test data
+	err = store.engine.DeleteByPrefix(ctx, key)
+	assert.Nil(t, err)
+}
+
 func TestTikvStore_Log(t *testing.T) {
 	ctx := context.Background()
 
@@ -198,10 +234,10 @@ func TestTikvStore_SegmentIndex(t *testing.T) {
 	assert.Nil(t, err)
 
 	// Get segment index
-	index , err := store.GetSegmentIndex(ctx, "segment0")
+	index, err := store.GetSegmentIndex(ctx, "segment0")
 	assert.Nil(t, err)
 	assert.Equal(t, []byte("index0"), index)
-	index , err = store.GetSegmentIndex(ctx, "segment1")
+	index, err = store.GetSegmentIndex(ctx, "segment1")
 	assert.Nil(t, err)
 	assert.Equal(t, []byte("index1"), index)
 
@@ -210,7 +246,7 @@ func TestTikvStore_SegmentIndex(t *testing.T) {
 	assert.Nil(t, err)
 	err = store.DeleteSegmentIndex(ctx, "segment1")
 	assert.Nil(t, err)
-	index , err = store.GetSegmentIndex(ctx, "segment0")
+	index, err = store.GetSegmentIndex(ctx, "segment0")
 	assert.Nil(t, err)
 	assert.Nil(t, index)
 }
@@ -225,10 +261,10 @@ func TestTikvStore_DeleteSegmentDL(t *testing.T) {
 	assert.Nil(t, err)
 
 	// Get segment delete log
-	index , err := store.GetSegmentDL(ctx, "segment0")
+	index, err := store.GetSegmentDL(ctx, "segment0")
 	assert.Nil(t, err)
 	assert.Equal(t, []byte("index0"), index)
-	index , err = store.GetSegmentDL(ctx, "segment1")
+	index, err = store.GetSegmentDL(ctx, "segment1")
 	assert.Nil(t, err)
 	assert.Equal(t, []byte("index1"), index)
 
@@ -237,7 +273,7 @@ func TestTikvStore_DeleteSegmentDL(t *testing.T) {
 	assert.Nil(t, err)
 	err = store.DeleteSegmentDL(ctx, "segment1")
 	assert.Nil(t, err)
-	index , err = store.GetSegmentDL(ctx, "segment0")
+	index, err = store.GetSegmentDL(ctx, "segment0")
 	assert.Nil(t, err)
 	assert.Nil(t, index)
 }

storage/pkg/types/types.go

@@ -50,10 +50,12 @@ type Store interface {
 	GetRows(ctx context.Context, keys []Key, timestamp Timestamp) ([]Value, error)
 
 	PutRow(ctx context.Context, key Key, value Value, segment string, timestamp Timestamp) error
-	PutRows(ctx context.Context, keys []Key, values []Value, segment string, timestamp Timestamp) error
+	PutRows(ctx context.Context, keys []Key, values []Value, segment string, timestamp []Timestamp) error
+
+	GetSegments(ctx context.Context, key Key, timestamp Timestamp) ([]string, error)
 
 	DeleteRow(ctx context.Context, key Key, timestamp Timestamp) error
-	DeleteRows(ctx context.Context, keys []Key, timestamp Timestamp) error
+	DeleteRows(ctx context.Context, keys []Key, timestamp []Timestamp) error
 
 	PutLog(ctx context.Context, key Key, value Value, timestamp Timestamp, channel int) error
 	GetLog(ctx context.Context, start Timestamp, end Timestamp, channels []int) ([]Value, error)