diff --git a/proxy/CMakeLists.txt b/proxy/CMakeLists.txt index 47159345c7b84616b7759610733ed551ff2cff29..f9dba4161fe70bb414bb79780fa8fe72a325fa97 100644 --- a/proxy/CMakeLists.txt +++ b/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 diff --git a/proxy/conf/demo/server_config.yaml b/proxy/conf/demo/server_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b9626eb95246ed387a597d321e5fec1ad9f74789 --- /dev/null +++ b/proxy/conf/demo/server_config.yaml @@ -0,0 +1,187 @@ +# 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 + diff --git a/proxy/conf/log_config.conf b/proxy/conf/log_config.conf new file mode 100644 index 0000000000000000000000000000000000000000..574ccc2b5fc90010fcb57301ad412de8bd9a7517 --- /dev/null +++ b/proxy/conf/log_config.conf @@ -0,0 +1,27 @@ +* 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" diff --git a/proxy/conf/server_config.template b/proxy/conf/server_config.template new file mode 100644 index 0000000000000000000000000000000000000000..2ccab5e20052b3bb04dd198fd2befd5bb9b5e41f --- /dev/null +++ b/proxy/conf/server_config.template @@ -0,0 +1,188 @@ +# 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 + diff --git a/proxy/conf/server_config.yaml b/proxy/conf/server_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..24dc3e2bd4deeb96dcfe56f886cfc75114b38408 --- /dev/null +++ b/proxy/conf/server_config.yaml @@ -0,0 +1,188 @@ +# 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 + diff --git a/proxy/conf/tracing_config.json b/proxy/conf/tracing_config.json new file mode 100644 index 0000000000000000000000000000000000000000..3a80614390636322550a2ebb2b3a3938f237af31 --- /dev/null +++ b/proxy/conf/tracing_config.json @@ -0,0 +1,26 @@ +{ + "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": "" + } + } +} diff --git a/proxy/src/CMakeLists.txt b/proxy/src/CMakeLists.txt index f32199a222b5591dd0da0a22a4abb63128cb5d91..4df65b52dc79039c2b9da458979819a8502721ad 100644 --- a/proxy/src/CMakeLists.txt +++ b/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 ) diff --git a/proxy/src/grpc/cpp_gen.sh b/proxy/src/grpc/cpp_gen.sh index 24e6270d7443b0c1e6b18ba9853bf2404836d520..04e66ef5eb375bdbd70d2f506a0915b9984339d7 100755 --- a/proxy/src/grpc/cpp_gen.sh +++ b/proxy/src/grpc/cpp_gen.sh @@ -1,9 +1,18 @@ #!/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 diff --git a/proxy/src/grpc/gen-milvus/hello.grpc.pb.cc b/proxy/src/grpc/gen-milvus/hello.grpc.pb.cc new file mode 100644 index 0000000000000000000000000000000000000000..279efed628c3f243389c9ccf1665293eec54f88b --- /dev/null +++ b/proxy/src/grpc/gen-milvus/hello.grpc.pb.cc @@ -0,0 +1,85 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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 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 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 + diff --git a/proxy/src/grpc/gen-milvus/hello.grpc.pb.h b/proxy/src/grpc/gen-milvus/hello.grpc.pb.h new file mode 100644 index 0000000000000000000000000000000000000000..a179c4f521b8bd25686da6d985f1e0444b441166 --- /dev/null +++ b/proxy/src/grpc/gen-milvus/hello.grpc.pb.h @@ -0,0 +1,254 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc_impl { +class CompletionQueue; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc_impl + +namespace grpc { +namespace experimental { +template +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) = 0; + virtual void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, std::function) = 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) override; + void SayHello(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HelloReply* response, std::function) 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 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 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 AsyncService; + template + 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 ExperimentalCallbackService; + template + 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 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 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 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::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 StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_SayHello StreamedService; +}; + +} // namespace grpc +} // namespace milvus + + +#endif // GRPC_hello_2eproto__INCLUDED diff --git a/proxy/src/grpc/gen-milvus/hello.pb.cc b/proxy/src/grpc/gen-milvus/hello.pb.cc new file mode 100644 index 0000000000000000000000000000000000000000..6a4380b48490518cc0446ccc2d3e9f63e90c5969 --- /dev/null +++ b/proxy/src/grpc/gen-milvus/hello.pb.cc @@ -0,0 +1,664 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: hello.proto + +#include "hello.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +namespace milvus { +namespace grpc { +class HelloRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HelloRequest_default_instance_; +class HelloReplyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HelloReply_default_instance_; +} // namespace grpc +} // namespace milvus +static void InitDefaultsscc_info_HelloReply_hello_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HelloReply_default_instance_; + new (ptr) ::milvus::grpc::HelloReply(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HelloReply::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HelloReply_hello_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HelloReply_hello_2eproto}, {}}; + +static void InitDefaultsscc_info_HelloRequest_hello_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HelloRequest_default_instance_; + new (ptr) ::milvus::grpc::HelloRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HelloRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HelloRequest_hello_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HelloRequest_hello_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_hello_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_hello_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_hello_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_hello_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HelloRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HelloRequest, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HelloReply, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HelloReply, msg_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::milvus::grpc::HelloRequest)}, + { 6, -1, sizeof(::milvus::grpc::HelloReply)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::milvus::grpc::_HelloRequest_default_instance_), + reinterpret_cast(&::milvus::grpc::_HelloReply_default_instance_), +}; + +const char descriptor_table_protodef_hello_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\013hello.proto\022\013milvus.grpc\"\034\n\014HelloReque" + "st\022\014\n\004name\030\001 \001(\t\"\031\n\nHelloReply\022\013\n\003msg\030\001 " + "\001(\t2P\n\014HelloService\022@\n\010SayHello\022\031.milvus" + ".grpc.HelloRequest\032\027.milvus.grpc.HelloRe" + "ply\"\000b\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_hello_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_hello_2eproto_sccs[2] = { + &scc_info_HelloReply_hello_2eproto.base, + &scc_info_HelloRequest_hello_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_hello_2eproto_once; +static bool descriptor_table_hello_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_hello_2eproto = { + &descriptor_table_hello_2eproto_initialized, descriptor_table_protodef_hello_2eproto, "hello.proto", 173, + &descriptor_table_hello_2eproto_once, descriptor_table_hello_2eproto_sccs, descriptor_table_hello_2eproto_deps, 2, 0, + schemas, file_default_instances, TableStruct_hello_2eproto::offsets, + file_level_metadata_hello_2eproto, 2, file_level_enum_descriptors_hello_2eproto, file_level_service_descriptors_hello_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_hello_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_hello_2eproto), true); +namespace milvus { +namespace grpc { + +// =================================================================== + +void HelloRequest::InitAsDefaultInstance() { +} +class HelloRequest::_Internal { + public: +}; + +HelloRequest::HelloRequest() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HelloRequest) +} +HelloRequest::HelloRequest(const HelloRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HelloRequest) +} + +void HelloRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HelloRequest_hello_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HelloRequest::~HelloRequest() { + // @@protoc_insertion_point(destructor:milvus.grpc.HelloRequest) + SharedDtor(); +} + +void HelloRequest::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HelloRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HelloRequest& HelloRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HelloRequest_hello_2eproto.base); + return *internal_default_instance(); +} + + +void HelloRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HelloRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HelloRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "milvus.grpc.HelloRequest.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool HelloRequest::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.HelloRequest) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HelloRequest.name")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HelloRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HelloRequest) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HelloRequest::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HelloRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HelloRequest.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HelloRequest) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HelloRequest::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HelloRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HelloRequest.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.HelloRequest) + return target; +} + +size_t HelloRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HelloRequest) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HelloRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HelloRequest) + GOOGLE_DCHECK_NE(&from, this); + const HelloRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HelloRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HelloRequest) + MergeFrom(*source); + } +} + +void HelloRequest::MergeFrom(const HelloRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HelloRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } +} + +void HelloRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HelloRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HelloRequest::CopyFrom(const HelloRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HelloRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HelloRequest::IsInitialized() const { + return true; +} + +void HelloRequest::InternalSwap(HelloRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HelloRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HelloReply::InitAsDefaultInstance() { +} +class HelloReply::_Internal { + public: +}; + +HelloReply::HelloReply() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HelloReply) +} +HelloReply::HelloReply(const HelloReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + msg_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.msg().empty()) { + msg_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.msg_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HelloReply) +} + +void HelloReply::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HelloReply_hello_2eproto.base); + msg_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HelloReply::~HelloReply() { + // @@protoc_insertion_point(destructor:milvus.grpc.HelloReply) + SharedDtor(); +} + +void HelloReply::SharedDtor() { + msg_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HelloReply::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HelloReply& HelloReply::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HelloReply_hello_2eproto.base); + return *internal_default_instance(); +} + + +void HelloReply::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HelloReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + msg_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HelloReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string msg = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_msg(), ptr, ctx, "milvus.grpc.HelloReply.msg"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool HelloReply::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.HelloReply) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string msg = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_msg())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->msg().data(), static_cast(this->msg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HelloReply.msg")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HelloReply) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HelloReply) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HelloReply::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HelloReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string msg = 1; + if (this->msg().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->msg().data(), static_cast(this->msg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HelloReply.msg"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->msg(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HelloReply) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HelloReply::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HelloReply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string msg = 1; + if (this->msg().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->msg().data(), static_cast(this->msg().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HelloReply.msg"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->msg(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.HelloReply) + return target; +} + +size_t HelloReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HelloReply) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string msg = 1; + if (this->msg().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->msg()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HelloReply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HelloReply) + GOOGLE_DCHECK_NE(&from, this); + const HelloReply* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HelloReply) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HelloReply) + MergeFrom(*source); + } +} + +void HelloReply::MergeFrom(const HelloReply& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HelloReply) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.msg().size() > 0) { + + msg_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.msg_); + } +} + +void HelloReply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HelloReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HelloReply::CopyFrom(const HelloReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HelloReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HelloReply::IsInitialized() const { + return true; +} + +void HelloReply::InternalSwap(HelloReply* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + msg_.Swap(&other->msg_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HelloReply::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace grpc +} // namespace milvus +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::milvus::grpc::HelloRequest* Arena::CreateMaybeMessage< ::milvus::grpc::HelloRequest >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HelloRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HelloReply* Arena::CreateMaybeMessage< ::milvus::grpc::HelloReply >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HelloReply >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/proxy/src/grpc/gen-milvus/hello.pb.h b/proxy/src/grpc/gen-milvus/hello.pb.h new file mode 100644 index 0000000000000000000000000000000000000000..004112d8345d9a1b3c5cf5395ef8c99694d4d926 --- /dev/null +++ b/proxy/src/grpc/gen-milvus/hello.pb.h @@ -0,0 +1,479 @@ +// 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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#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( + &_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(nullptr); + } + + HelloRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const 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( + &_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(nullptr); + } + + HelloReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const 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(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(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 +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_hello_2eproto diff --git a/proxy/src/grpc/gen-milvus/master.grpc.pb.cc b/proxy/src/grpc/gen-milvus/master.grpc.pb.cc new file mode 100644 index 0000000000000000000000000000000000000000..7d89b50e28cb800681186917baf2c85f37bb1056 --- /dev/null +++ b/proxy/src/grpc/gen-milvus/master.grpc.pb.cc @@ -0,0 +1,125 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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 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 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 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 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 + diff --git a/proxy/src/grpc/gen-milvus/master.grpc.pb.h b/proxy/src/grpc/gen-milvus/master.grpc.pb.h new file mode 100644 index 0000000000000000000000000000000000000000..f8116f7dc8bf456226d0683725387e6cb4c6b31e --- /dev/null +++ b/proxy/src/grpc/gen-milvus/master.grpc.pb.h @@ -0,0 +1,420 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: master.proto +#ifndef GRPC_master_2eproto__INCLUDED +#define GRPC_master_2eproto__INCLUDED + +#include "master.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc_impl { +class CompletionQueue; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc_impl + +namespace grpc { +namespace experimental { +template +class MessageAllocator; +} // namespace experimental +} // namespace grpc + +namespace master { + +// The greeting service definition. +class Greeter final { + public: + static constexpr char const* service_full_name() { + return "master.Greeter"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // receive a grpc_server address and set to etcd. + virtual ::grpc::Status ReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::master::Reply* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>> AsyncReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>>(AsyncReportAddressRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>> PrepareAsyncReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>>(PrepareAsyncReportAddressRaw(context, request, cq)); + } + // send a grpc_server address to client + virtual ::grpc::Status GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::master::Request* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>> AsyncGetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>>(AsyncGetAddressRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>> PrepareAsyncGetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>>(PrepareAsyncGetAddressRaw(context, request, cq)); + } + class experimental_async_interface { + public: + virtual ~experimental_async_interface() {} + // receive a grpc_server address and set to etcd. + virtual void ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, std::function) = 0; + virtual void ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, std::function) = 0; + virtual void ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // send a grpc_server address to client + virtual void GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, std::function) = 0; + virtual void GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* response, std::function) = 0; + virtual void GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + }; + virtual class experimental_async_interface* experimental_async() { return nullptr; } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>* AsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::master::Reply>* PrepareAsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>* AsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::master::Request>* PrepareAsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status ReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::master::Reply* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Reply>> AsyncReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Reply>>(AsyncReportAddressRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Reply>> PrepareAsyncReportAddress(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Reply>>(PrepareAsyncReportAddressRaw(context, request, cq)); + } + ::grpc::Status GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::master::Request* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Request>> AsyncGetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Request>>(AsyncGetAddressRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Request>> PrepareAsyncGetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::master::Request>>(PrepareAsyncGetAddressRaw(context, request, cq)); + } + class experimental_async final : + public StubInterface::experimental_async_interface { + public: + void ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, std::function) override; + void ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, std::function) override; + void ReportAddress(::grpc::ClientContext* context, const ::master::Request* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ReportAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Reply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, std::function) override; + void GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* response, std::function) override; + void GetAddress(::grpc::ClientContext* context, const ::master::EmptyRequest* request, ::master::Request* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetAddress(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::master::Request* 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< ::master::Reply>* AsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::master::Reply>* PrepareAsyncReportAddressRaw(::grpc::ClientContext* context, const ::master::Request& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::master::Request>* AsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::master::Request>* PrepareAsyncGetAddressRaw(::grpc::ClientContext* context, const ::master::EmptyRequest& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_ReportAddress_; + const ::grpc::internal::RpcMethod rpcmethod_GetAddress_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // receive a grpc_server address and set to etcd. + virtual ::grpc::Status ReportAddress(::grpc::ServerContext* context, const ::master::Request* request, ::master::Reply* response); + // send a grpc_server address to client + virtual ::grpc::Status GetAddress(::grpc::ServerContext* context, const ::master::EmptyRequest* request, ::master::Request* response); + }; + template + class WithAsyncMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ReportAddress() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReportAddress(::grpc::ServerContext* context, ::master::Request* request, ::grpc::ServerAsyncResponseWriter< ::master::Reply>* 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 WithAsyncMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetAddress() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetAddress(::grpc::ServerContext* context, ::master::EmptyRequest* request, ::grpc::ServerAsyncResponseWriter< ::master::Request>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_ReportAddress > AsyncService; + template + class ExperimentalWithCallbackMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ReportAddress() { + ::grpc::Service::experimental().MarkMethodCallback(0, + new ::grpc_impl::internal::CallbackUnaryHandler< ::master::Request, ::master::Reply>( + [this](::grpc::ServerContext* context, + const ::master::Request* request, + ::master::Reply* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ReportAddress(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ReportAddress( + ::grpc::experimental::MessageAllocator< ::master::Request, ::master::Reply>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::master::Request, ::master::Reply>*>( + ::grpc::Service::experimental().GetHandler(0)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_GetAddress() { + ::grpc::Service::experimental().MarkMethodCallback(1, + new ::grpc_impl::internal::CallbackUnaryHandler< ::master::EmptyRequest, ::master::Request>( + [this](::grpc::ServerContext* context, + const ::master::EmptyRequest* request, + ::master::Request* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->GetAddress(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_GetAddress( + ::grpc::experimental::MessageAllocator< ::master::EmptyRequest, ::master::Request>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::master::EmptyRequest, ::master::Request>*>( + ::grpc::Service::experimental().GetHandler(1)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + typedef ExperimentalWithCallbackMethod_ReportAddress > ExperimentalCallbackService; + template + class WithGenericMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ReportAddress() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetAddress() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ReportAddress() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReportAddress(::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 WithRawMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetAddress() { + ::grpc::Service::MarkMethodRaw(1); + } + ~WithRawMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetAddress(::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(1, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class ExperimentalWithRawCallbackMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ReportAddress() { + ::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->ReportAddress(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReportAddress(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_GetAddress() { + ::grpc::Service::experimental().MarkMethodRawCallback(1, + 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->GetAddress(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetAddress(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class WithStreamedUnaryMethod_ReportAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ReportAddress() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< ::master::Request, ::master::Reply>(std::bind(&WithStreamedUnaryMethod_ReportAddress::StreamedReportAddress, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ReportAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ReportAddress(::grpc::ServerContext* /*context*/, const ::master::Request* /*request*/, ::master::Reply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedReportAddress(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::master::Request,::master::Reply>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetAddress : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetAddress() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::StreamedUnaryHandler< ::master::EmptyRequest, ::master::Request>(std::bind(&WithStreamedUnaryMethod_GetAddress::StreamedGetAddress, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_GetAddress() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetAddress(::grpc::ServerContext* /*context*/, const ::master::EmptyRequest* /*request*/, ::master::Request* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetAddress(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::master::EmptyRequest,::master::Request>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_ReportAddress > StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_ReportAddress > StreamedService; +}; + +} // namespace master + + +#endif // GRPC_master_2eproto__INCLUDED diff --git a/proxy/src/grpc/gen-milvus/master.pb.cc b/proxy/src/grpc/gen-milvus/master.pb.cc new file mode 100644 index 0000000000000000000000000000000000000000..3b34b2e6eb5e355ea106bea178d2fa468c12a1bd --- /dev/null +++ b/proxy/src/grpc/gen-milvus/master.pb.cc @@ -0,0 +1,867 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: master.proto + +#include "master.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +namespace master { +class RequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Request_default_instance_; +class EmptyRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _EmptyRequest_default_instance_; +class ReplyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Reply_default_instance_; +} // namespace master +static void InitDefaultsscc_info_EmptyRequest_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::master::_EmptyRequest_default_instance_; + new (ptr) ::master::EmptyRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::master::EmptyRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EmptyRequest_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_EmptyRequest_master_2eproto}, {}}; + +static void InitDefaultsscc_info_Reply_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::master::_Reply_default_instance_; + new (ptr) ::master::Reply(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::master::Reply::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Reply_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Reply_master_2eproto}, {}}; + +static void InitDefaultsscc_info_Request_master_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::master::_Request_default_instance_; + new (ptr) ::master::Request(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::master::Request::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Request_master_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Request_master_2eproto}, {}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_master_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_master_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_master_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_master_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::master::Request, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::master::Request, address_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::master::EmptyRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::master::Reply, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::master::Reply, status_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::master::Request)}, + { 6, -1, sizeof(::master::EmptyRequest)}, + { 11, -1, sizeof(::master::Reply)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::master::_Request_default_instance_), + reinterpret_cast(&::master::_EmptyRequest_default_instance_), + reinterpret_cast(&::master::_Reply_default_instance_), +}; + +const char descriptor_table_protodef_master_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\014master.proto\022\006master\"\032\n\007Request\022\017\n\007add" + "ress\030\001 \001(\t\"\016\n\014EmptyRequest\"\027\n\005Reply\022\016\n\006s" + "tatus\030\001 \001(\0102s\n\007Greeter\0221\n\rReportAddress\022" + "\017.master.Request\032\r.master.Reply\"\000\0225\n\nGet" + "Address\022\024.master.EmptyRequest\032\017.master.R" + "equest\"\000b\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_master_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_master_2eproto_sccs[3] = { + &scc_info_EmptyRequest_master_2eproto.base, + &scc_info_Reply_master_2eproto.base, + &scc_info_Request_master_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_master_2eproto_once; +static bool descriptor_table_master_2eproto_initialized = false; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_master_2eproto = { + &descriptor_table_master_2eproto_initialized, descriptor_table_protodef_master_2eproto, "master.proto", 216, + &descriptor_table_master_2eproto_once, descriptor_table_master_2eproto_sccs, descriptor_table_master_2eproto_deps, 3, 0, + schemas, file_default_instances, TableStruct_master_2eproto::offsets, + file_level_metadata_master_2eproto, 3, file_level_enum_descriptors_master_2eproto, file_level_service_descriptors_master_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_master_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_master_2eproto), true); +namespace master { + +// =================================================================== + +void Request::InitAsDefaultInstance() { +} +class Request::_Internal { + public: +}; + +Request::Request() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:master.Request) +} +Request::Request(const Request& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.address().empty()) { + address_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.address_); + } + // @@protoc_insertion_point(copy_constructor:master.Request) +} + +void Request::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Request_master_2eproto.base); + address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Request::~Request() { + // @@protoc_insertion_point(destructor:master.Request) + SharedDtor(); +} + +void Request::SharedDtor() { + address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Request::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Request& Request::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Request_master_2eproto.base); + return *internal_default_instance(); +} + + +void Request::Clear() { +// @@protoc_insertion_point(message_clear_start:master.Request) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + address_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Request::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string address = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_address(), ptr, ctx, "master.Request.address"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Request::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:master.Request) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string address = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_address())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->address().data(), static_cast(this->address().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "master.Request.address")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:master.Request) + return true; +failure: + // @@protoc_insertion_point(parse_failure:master.Request) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Request::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:master.Request) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string address = 1; + if (this->address().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->address().data(), static_cast(this->address().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "master.Request.address"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->address(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:master.Request) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Request::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:master.Request) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string address = 1; + if (this->address().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->address().data(), static_cast(this->address().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "master.Request.address"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->address(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:master.Request) + return target; +} + +size_t Request::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:master.Request) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string address = 1; + if (this->address().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->address()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Request::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:master.Request) + GOOGLE_DCHECK_NE(&from, this); + const Request* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:master.Request) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:master.Request) + MergeFrom(*source); + } +} + +void Request::MergeFrom(const Request& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:master.Request) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.address().size() > 0) { + + address_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.address_); + } +} + +void Request::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:master.Request) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Request::CopyFrom(const Request& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:master.Request) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Request::IsInitialized() const { + return true; +} + +void Request::InternalSwap(Request* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + address_.Swap(&other->address_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Request::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void EmptyRequest::InitAsDefaultInstance() { +} +class EmptyRequest::_Internal { + public: +}; + +EmptyRequest::EmptyRequest() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:master.EmptyRequest) +} +EmptyRequest::EmptyRequest(const EmptyRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:master.EmptyRequest) +} + +void EmptyRequest::SharedCtor() { +} + +EmptyRequest::~EmptyRequest() { + // @@protoc_insertion_point(destructor:master.EmptyRequest) + SharedDtor(); +} + +void EmptyRequest::SharedDtor() { +} + +void EmptyRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const EmptyRequest& EmptyRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EmptyRequest_master_2eproto.base); + return *internal_default_instance(); +} + + +void EmptyRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:master.EmptyRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* EmptyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + default: { + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool EmptyRequest::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:master.EmptyRequest) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + } +success: + // @@protoc_insertion_point(parse_success:master.EmptyRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:master.EmptyRequest) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void EmptyRequest::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:master.EmptyRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:master.EmptyRequest) +} + +::PROTOBUF_NAMESPACE_ID::uint8* EmptyRequest::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:master.EmptyRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:master.EmptyRequest) + return target; +} + +size_t EmptyRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:master.EmptyRequest) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void EmptyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:master.EmptyRequest) + GOOGLE_DCHECK_NE(&from, this); + const EmptyRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:master.EmptyRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:master.EmptyRequest) + MergeFrom(*source); + } +} + +void EmptyRequest::MergeFrom(const EmptyRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:master.EmptyRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void EmptyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:master.EmptyRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void EmptyRequest::CopyFrom(const EmptyRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:master.EmptyRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool EmptyRequest::IsInitialized() const { + return true; +} + +void EmptyRequest::InternalSwap(EmptyRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata EmptyRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Reply::InitAsDefaultInstance() { +} +class Reply::_Internal { + public: +}; + +Reply::Reply() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:master.Reply) +} +Reply::Reply(const Reply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + status_ = from.status_; + // @@protoc_insertion_point(copy_constructor:master.Reply) +} + +void Reply::SharedCtor() { + status_ = false; +} + +Reply::~Reply() { + // @@protoc_insertion_point(destructor:master.Reply) + SharedDtor(); +} + +void Reply::SharedDtor() { +} + +void Reply::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Reply& Reply::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Reply_master_2eproto.base); + return *internal_default_instance(); +} + + +void Reply::Clear() { +// @@protoc_insertion_point(message_clear_start:master.Reply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + status_ = false; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Reply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // bool status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + status_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool Reply::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:master.Reply) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // bool status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &status_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:master.Reply) + return true; +failure: + // @@protoc_insertion_point(parse_failure:master.Reply) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Reply::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:master.Reply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bool status = 1; + if (this->status() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->status(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:master.Reply) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Reply::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:master.Reply) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bool status = 1; + if (this->status() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->status(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:master.Reply) + return target; +} + +size_t Reply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:master.Reply) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bool status = 1; + if (this->status() != 0) { + total_size += 1 + 1; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Reply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:master.Reply) + GOOGLE_DCHECK_NE(&from, this); + const Reply* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:master.Reply) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:master.Reply) + MergeFrom(*source); + } +} + +void Reply::MergeFrom(const Reply& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:master.Reply) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.status() != 0) { + set_status(from.status()); + } +} + +void Reply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:master.Reply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Reply::CopyFrom(const Reply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:master.Reply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Reply::IsInitialized() const { + return true; +} + +void Reply::InternalSwap(Reply* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Reply::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace master +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::master::Request* Arena::CreateMaybeMessage< ::master::Request >(Arena* arena) { + return Arena::CreateInternal< ::master::Request >(arena); +} +template<> PROTOBUF_NOINLINE ::master::EmptyRequest* Arena::CreateMaybeMessage< ::master::EmptyRequest >(Arena* arena) { + return Arena::CreateInternal< ::master::EmptyRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::master::Reply* Arena::CreateMaybeMessage< ::master::Reply >(Arena* arena) { + return Arena::CreateInternal< ::master::Reply >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/proxy/src/grpc/gen-milvus/master.pb.h b/proxy/src/grpc/gen-milvus/master.pb.h new file mode 100644 index 0000000000000000000000000000000000000000..d4c8f8fb5124f0f8f20c526021f89b54a4ef47de --- /dev/null +++ b/proxy/src/grpc/gen-milvus/master.pb.h @@ -0,0 +1,564 @@ +// 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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#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( + &_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(nullptr); + } + + Request* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const 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( + &_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(nullptr); + } + + EmptyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const 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( + &_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(nullptr); + } + + Reply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const 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(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 +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_master_2eproto diff --git a/proxy/src/grpc/hello.proto b/proxy/src/grpc/hello.proto new file mode 100644 index 0000000000000000000000000000000000000000..0ca7a876a477ec9e3ab3feb7c95fa6ae3ec839c6 --- /dev/null +++ b/proxy/src/grpc/hello.proto @@ -0,0 +1,15 @@ +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 diff --git a/proxy/src/grpc/master.proto b/proxy/src/grpc/master.proto new file mode 100644 index 0000000000000000000000000000000000000000..78f1cbb5c1ff9e480704ac059d4b5d3dfa13268d --- /dev/null +++ b/proxy/src/grpc/master.proto @@ -0,0 +1,26 @@ +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 diff --git a/proxy/src/server/CMakeLists.txt b/proxy/src/server/CMakeLists.txt index de9ef688f91f16e2d638d5a79dd95015ab20b76a..974b2f71dd9b8242addcc43393c91a756f686ac4 100644 --- a/proxy/src/server/CMakeLists.txt +++ b/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 ) diff --git a/proxy/src/server/grpc_impl/GrpcServer.cpp b/proxy/src/server/grpc_impl/GrpcServer.cpp index a7ac19043c218a666dc851d51b09be8d03e3d8eb..ed77ae2b4821125c1c997dca77a9e1e20a6374b9 100644 --- a/proxy/src/server/grpc_impl/GrpcServer.cpp +++ b/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; diff --git a/proxy/src/server/hello/HelloService.h b/proxy/src/server/hello/HelloService.h new file mode 100644 index 0000000000000000000000000000000000000000..b798a054cf3d5736aa4f286c1aedcf1d0f40b968 --- /dev/null +++ b/proxy/src/server/hello/HelloService.h @@ -0,0 +1,17 @@ +#ifndef MILVUS_HELLOSERVICE_H +#define MILVUS_HELLOSERVICE_H + +#include "grpc++/grpc++.h" +#include + +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 diff --git a/proxy/src/server/hello/ReportAddress.h b/proxy/src/server/hello/ReportAddress.h new file mode 100644 index 0000000000000000000000000000000000000000..2218d4c287392b531f42e0fa9efb166b0358f081 --- /dev/null +++ b/proxy/src/server/hello/ReportAddress.h @@ -0,0 +1,30 @@ +#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 stub_; +}; \ No newline at end of file diff --git a/proxy/src/version.h b/proxy/src/version.h index 123176a5dcf9864f3ac6d98adf0ae5031bf29c07..59e389708e5a3dc29cf10e8285a63f0605c56986 100644 --- a/proxy/src/version.h +++ b/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" diff --git a/proxy/thirdparty/CMakeLists.txt b/proxy/thirdparty/CMakeLists.txt index 68c4f2a352f2568ebb5efaeae80715b7ab22a347..c08a2d180950f9bea97882d2c88ad142da04c0ee 100644 --- a/proxy/thirdparty/CMakeLists.txt +++ b/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 diff --git a/proxy/thirdparty/pulsar-client-cpp/CMakeLists.txt b/proxy/thirdparty/pulsar-client-cpp/CMakeLists.txt deleted file mode 100644 index 332f3bf215cac6e4b79865ea865a9081ae6129b6..0000000000000000000000000000000000000000 --- a/proxy/thirdparty/pulsar-client-cpp/CMakeLists.txt +++ /dev/null @@ -1,57 +0,0 @@ -#------------------------------------------------------------------------------- -# 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. -#------------------------------------------------------------------------------- - -if (DEFINED ENV{MILVUS_PULSAR_URL}) - set(PULSAR_URL "$ENV{MILVUS_PULSAR_URL}") -else () - set(PULSAR_URL - "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( -# 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 -#) -# -#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}") diff --git a/proxy/thirdparty/pulsar/CMakeLists b/proxy/thirdparty/pulsar/CMakeLists new file mode 100644 index 0000000000000000000000000000000000000000..91e6b76d1664fe5dfeb55912eb6a5cb7601b0c36 --- /dev/null +++ b/proxy/thirdparty/pulsar/CMakeLists @@ -0,0 +1,314 @@ +### 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 diff --git a/proxy/thirdparty/pulsar/CMakeLists.txt b/proxy/thirdparty/pulsar/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..1beb217c6d3bb998a5bf293d06964eac17e68dbf --- /dev/null +++ b/proxy/thirdparty/pulsar/CMakeLists.txt @@ -0,0 +1,68 @@ +#------------------------------------------------------------------------------- +# 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. +#------------------------------------------------------------------------------- + +if (DEFINED ENV{MILVUS_PULSAR_URL}) + set(PULSAR_URL "$ENV{MILVUS_PULSAR_URL}") +else () + set(PULSAR_URL + "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 && cmake . +# BUILD_IN_SOURCE true +# INSTALL_COMMAND cd ${pulsar_ROOT}/src/pulsar/pulsar-client-cpp && make install +#) + + + +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}") diff --git a/storage/internal/tikv/tikv_store.go b/storage/internal/tikv/tikv_store.go index 1a0de3e23254ad96122063d1279f9b077aa0aeb4..5924418d0566bb69fb51268affdd5823f7076ed1 100644 --- a/storage/internal/tikv/tikv_store.go +++ b/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() } diff --git a/storage/internal/tikv/tikv_test.go b/storage/internal/tikv/tikv_test.go index 4a236cb8a461dbe31c2166de686f83b8ab322e34..c8d82ac9ca21c69a9f45e4e2d19294102691c393 100644 --- a/storage/internal/tikv/tikv_test.go +++ b/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) } diff --git a/storage/pkg/types/types.go b/storage/pkg/types/types.go index 1aa2ad6fe9f66374202a9f9a4e16a73920929cb6..4ad33754a2c1c284fbbbc32b5c0b6338156165c6 100644 --- a/storage/pkg/types/types.go +++ b/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)