def beta_create_UpdateStream_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import binlogdata_pb2 import binlogdata_pb2 import binlogdata_pb2 import binlogdata_pb2 import binlogdata_pb2 import binlogdata_pb2 request_deserializers = { ("binlogservice.UpdateStream", "StreamKeyRange"): binlogdata_pb2.StreamKeyRangeRequest.FromString, ("binlogservice.UpdateStream", "StreamTables"): binlogdata_pb2.StreamTablesRequest.FromString, ("binlogservice.UpdateStream", "StreamUpdate"): binlogdata_pb2.StreamUpdateRequest.FromString, } response_serializers = { ("binlogservice.UpdateStream", "StreamKeyRange"): binlogdata_pb2.StreamKeyRangeResponse.SerializeToString, ("binlogservice.UpdateStream", "StreamTables"): binlogdata_pb2.StreamTablesResponse.SerializeToString, ("binlogservice.UpdateStream", "StreamUpdate"): binlogdata_pb2.StreamUpdateResponse.SerializeToString, } method_implementations = { ("binlogservice.UpdateStream", "StreamKeyRange"): face_utilities.unary_stream_inline(servicer.StreamKeyRange), ("binlogservice.UpdateStream", "StreamTables"): face_utilities.unary_stream_inline(servicer.StreamTables), ("binlogservice.UpdateStream", "StreamUpdate"): face_utilities.unary_stream_inline(servicer.StreamUpdate), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout, ) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Bigtable_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): CheckAndMutateRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'MutateRow'): MutateRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'MutateRows'): MutateRowsRequest.FromString, ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): ReadModifyWriteRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'ReadRows'): ReadRowsRequest.FromString, ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): SampleRowKeysRequest.FromString, } response_serializers = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): CheckAndMutateRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'MutateRow'): MutateRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'MutateRows'): MutateRowsResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): ReadModifyWriteRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'ReadRows'): ReadRowsResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): SampleRowKeysResponse.SerializeToString, } method_implementations = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): face_utilities.unary_unary_inline(servicer.CheckAndMutateRow), ('google.bigtable.v2.Bigtable', 'MutateRow'): face_utilities.unary_unary_inline(servicer.MutateRow), ('google.bigtable.v2.Bigtable', 'MutateRows'): face_utilities.unary_stream_inline(servicer.MutateRows), ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): face_utilities.unary_unary_inline(servicer.ReadModifyWriteRow), ('google.bigtable.v2.Bigtable', 'ReadRows'): face_utilities.unary_stream_inline(servicer.ReadRows), ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): face_utilities.unary_stream_inline(servicer.SampleRowKeys), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfDatafeedService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 request_deserializers = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): bftrader_pb2.BfGetBarReq.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): bftrader_pb2.BfGetTickPackReq.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): bftrader_pb2.BfBarData.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): bftrader_pb2.BfTickPackData.FromString, } response_serializers = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): bftrader_pb2.BfBarData.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): bftrader_pb2.BfTickPackData.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): bftrader_pb2.BfVoid.SerializeToString, } method_implementations = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): face_utilities.unary_stream_inline(servicer.GetBar), ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): face_utilities.unary_stream_inline(servicer.GetTickPack), ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): face_utilities.unary_unary_inline(servicer.InsertBar), ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): face_utilities.unary_unary_inline(servicer.InsertTickPack), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BigtableService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import google.protobuf.empty_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_data_pb2 request_deserializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'MutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.MutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadModifyWriteRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadRows'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsRequest.FromString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysRequest.FromString, } response_serializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'MutateRow'): google.protobuf.empty_pb2.Empty.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): gcloud.bigtable._generated.bigtable_data_pb2.Row.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadRows'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysResponse.SerializeToString, } method_implementations = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): face_utilities.unary_unary_inline(servicer.CheckAndMutateRow), ('google.bigtable.v1.BigtableService', 'MutateRow'): face_utilities.unary_unary_inline(servicer.MutateRow), ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): face_utilities.unary_unary_inline(servicer.ReadModifyWriteRow), ('google.bigtable.v1.BigtableService', 'ReadRows'): face_utilities.unary_stream_inline(servicer.ReadRows), ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): face_utilities.unary_stream_inline(servicer.SampleRowKeys), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_DbService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('DbService', 'FetchDoctors'): Empty.FromString, ('DbService', 'FetchPatients'): Empty.FromString, ('DbService', 'FetchTechnicians'): Empty.FromString, ('DbService', 'NewDoctor'): Person.FromString, ('DbService', 'NewPatient'): Person.FromString, ('DbService', 'NewTechnician'): Person.FromString, } response_serializers = { ('DbService', 'FetchDoctors'): Doctor.SerializeToString, ('DbService', 'FetchPatients'): Patient.SerializeToString, ('DbService', 'FetchTechnicians'): Technician.SerializeToString, ('DbService', 'NewDoctor'): Doctor.SerializeToString, ('DbService', 'NewPatient'): Patient.SerializeToString, ('DbService', 'NewTechnician'): Technician.SerializeToString, } method_implementations = { ('DbService', 'FetchDoctors'): face_utilities.unary_stream_inline(servicer.FetchDoctors), ('DbService', 'FetchPatients'): face_utilities.unary_stream_inline(servicer.FetchPatients), ('DbService', 'FetchTechnicians'): face_utilities.unary_stream_inline(servicer.FetchTechnicians), ('DbService', 'NewDoctor'): face_utilities.unary_unary_inline(servicer.NewDoctor), ('DbService', 'NewPatient'): face_utilities.unary_unary_inline(servicer.NewPatient), ('DbService', 'NewTechnician'): face_utilities.unary_unary_inline(servicer.NewTechnician), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BigtableService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.CheckAndMutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'MutateRow'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.MutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'MutateRows'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.MutateRowsRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.ReadModifyWriteRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadRows'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.ReadRowsRequest.FromString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.SampleRowKeysRequest.FromString, } response_serializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.CheckAndMutateRowResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'MutateRow'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.bigtable.v1.BigtableService', 'MutateRows'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.MutateRowsResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): google_dot_bigtable_dot_v1_dot_bigtable__data__pb2.Row.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadRows'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.ReadRowsResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.SampleRowKeysResponse.SerializeToString, } method_implementations = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): face_utilities.unary_unary_inline(servicer.CheckAndMutateRow), ('google.bigtable.v1.BigtableService', 'MutateRow'): face_utilities.unary_unary_inline(servicer.MutateRow), ('google.bigtable.v1.BigtableService', 'MutateRows'): face_utilities.unary_unary_inline(servicer.MutateRows), ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): face_utilities.unary_unary_inline(servicer.ReadModifyWriteRow), ('google.bigtable.v1.BigtableService', 'ReadRows'): face_utilities.unary_stream_inline(servicer.ReadRows), ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): face_utilities.unary_stream_inline(servicer.SampleRowKeys), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Manager_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('Manager', 'AddPerson'): Person.FromString, ('Manager', 'DelPerson'): PersonId.FromString, ('Manager', 'ListContacts'): ContactsRequest.FromString, ('Manager', 'SearchPersonId'): PersonId.FromString, ('Manager', 'SearchPersonName'): PersonName.FromString, } response_serializers = { ('Manager', 'AddPerson'): BooleanReply.SerializeToString, ('Manager', 'DelPerson'): BooleanReply.SerializeToString, ('Manager', 'ListContacts'): Person.SerializeToString, ('Manager', 'SearchPersonId'): PersonReply.SerializeToString, ('Manager', 'SearchPersonName'): Person.SerializeToString, } method_implementations = { ('Manager', 'AddPerson'): face_utilities.unary_unary_inline(servicer.AddPerson), ('Manager', 'DelPerson'): face_utilities.unary_unary_inline(servicer.DelPerson), ('Manager', 'ListContacts'): face_utilities.unary_stream_inline(servicer.ListContacts), ('Manager', 'SearchPersonId'): face_utilities.unary_unary_inline(servicer.SearchPersonId), ('Manager', 'SearchPersonName'): face_utilities.unary_stream_inline(servicer.SearchPersonName), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vitess_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('vtgateservice.Vitess', 'Begin'): vtgate__pb2.BeginRequest.FromString, ('vtgateservice.Vitess', 'Commit'): vtgate__pb2.CommitRequest.FromString, ('vtgateservice.Vitess', 'Execute'): vtgate__pb2.ExecuteRequest.FromString, ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): vtgate__pb2.ExecuteBatchKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteBatchShards'): vtgate__pb2.ExecuteBatchShardsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteEntityIds'): vtgate__pb2.ExecuteEntityIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteKeyRanges'): vtgate__pb2.ExecuteKeyRangesRequest.FromString, ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): vtgate__pb2.ExecuteKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteShards'): vtgate__pb2.ExecuteShardsRequest.FromString, ('vtgateservice.Vitess', 'GetSrvKeyspace'): vtgate__pb2.GetSrvKeyspaceRequest.FromString, ('vtgateservice.Vitess', 'Rollback'): vtgate__pb2.RollbackRequest.FromString, ('vtgateservice.Vitess', 'SplitQuery'): vtgate__pb2.SplitQueryRequest.FromString, ('vtgateservice.Vitess', 'StreamExecute'): vtgate__pb2.StreamExecuteRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): vtgate__pb2.StreamExecuteKeyRangesRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): vtgate__pb2.StreamExecuteKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteShards'): vtgate__pb2.StreamExecuteShardsRequest.FromString, ('vtgateservice.Vitess', 'UpdateStream'): vtgate__pb2.UpdateStreamRequest.FromString, } response_serializers = { ('vtgateservice.Vitess', 'Begin'): vtgate__pb2.BeginResponse.SerializeToString, ('vtgateservice.Vitess', 'Commit'): vtgate__pb2.CommitResponse.SerializeToString, ('vtgateservice.Vitess', 'Execute'): vtgate__pb2.ExecuteResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): vtgate__pb2.ExecuteBatchKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteBatchShards'): vtgate__pb2.ExecuteBatchShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteEntityIds'): vtgate__pb2.ExecuteEntityIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteKeyRanges'): vtgate__pb2.ExecuteKeyRangesResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): vtgate__pb2.ExecuteKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteShards'): vtgate__pb2.ExecuteShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'GetSrvKeyspace'): vtgate__pb2.GetSrvKeyspaceResponse.SerializeToString, ('vtgateservice.Vitess', 'Rollback'): vtgate__pb2.RollbackResponse.SerializeToString, ('vtgateservice.Vitess', 'SplitQuery'): vtgate__pb2.SplitQueryResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecute'): vtgate__pb2.StreamExecuteResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): vtgate__pb2.StreamExecuteKeyRangesResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): vtgate__pb2.StreamExecuteKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteShards'): vtgate__pb2.StreamExecuteShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'UpdateStream'): vtgate__pb2.UpdateStreamResponse.SerializeToString, } method_implementations = { ('vtgateservice.Vitess', 'Begin'): face_utilities.unary_unary_inline(servicer.Begin), ('vtgateservice.Vitess', 'Commit'): face_utilities.unary_unary_inline(servicer.Commit), ('vtgateservice.Vitess', 'Execute'): face_utilities.unary_unary_inline(servicer.Execute), ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): face_utilities.unary_unary_inline(servicer.ExecuteBatchKeyspaceIds), ('vtgateservice.Vitess', 'ExecuteBatchShards'): face_utilities.unary_unary_inline(servicer.ExecuteBatchShards), ('vtgateservice.Vitess', 'ExecuteEntityIds'): face_utilities.unary_unary_inline(servicer.ExecuteEntityIds), ('vtgateservice.Vitess', 'ExecuteKeyRanges'): face_utilities.unary_unary_inline(servicer.ExecuteKeyRanges), ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): face_utilities.unary_unary_inline(servicer.ExecuteKeyspaceIds), ('vtgateservice.Vitess', 'ExecuteShards'): face_utilities.unary_unary_inline(servicer.ExecuteShards), ('vtgateservice.Vitess', 'GetSrvKeyspace'): face_utilities.unary_unary_inline(servicer.GetSrvKeyspace), ('vtgateservice.Vitess', 'Rollback'): face_utilities.unary_unary_inline(servicer.Rollback), ('vtgateservice.Vitess', 'SplitQuery'): face_utilities.unary_unary_inline(servicer.SplitQuery), ('vtgateservice.Vitess', 'StreamExecute'): face_utilities.unary_stream_inline(servicer.StreamExecute), ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): face_utilities.unary_stream_inline(servicer.StreamExecuteKeyRanges), ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): face_utilities.unary_stream_inline(servicer.StreamExecuteKeyspaceIds), ('vtgateservice.Vitess', 'StreamExecuteShards'): face_utilities.unary_stream_inline(servicer.StreamExecuteShards), ('vtgateservice.Vitess', 'UpdateStream'): face_utilities.unary_stream_inline(servicer.UpdateStream), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Deployer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('deployment.Deployer', 'Deploy'): DeploymentRequest.FromString, ('deployment.Deployer', 'ListDeploymentEvents'): ListDeploymentEventsRequest.FromString, } response_serializers = { ('deployment.Deployer', 'Deploy'): DeploymentEvent.SerializeToString, ('deployment.Deployer', 'ListDeploymentEvents'): DeploymentEvent.SerializeToString, } method_implementations = { ('deployment.Deployer', 'Deploy'): face_utilities.unary_stream_inline(servicer.Deploy), ('deployment.Deployer', 'ListDeploymentEvents'): face_utilities.unary_stream_inline(servicer.ListDeploymentEvents), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_UpdateStream_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('binlogservice.UpdateStream', 'StreamKeyRange'): binlogdata__pb2.StreamKeyRangeRequest.FromString, ('binlogservice.UpdateStream', 'StreamTables'): binlogdata__pb2.StreamTablesRequest.FromString, } response_serializers = { ('binlogservice.UpdateStream', 'StreamKeyRange'): binlogdata__pb2.StreamKeyRangeResponse.SerializeToString, ('binlogservice.UpdateStream', 'StreamTables'): binlogdata__pb2.StreamTablesResponse.SerializeToString, } method_implementations = { ('binlogservice.UpdateStream', 'StreamKeyRange'): face_utilities.unary_stream_inline(servicer.StreamKeyRange), ('binlogservice.UpdateStream', 'StreamTables'): face_utilities.unary_stream_inline(servicer.StreamTables), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfDatafeedService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfdatafeed_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 request_deserializers = { ('bftrader.BfDatafeedService', 'DeleteBar'): bfdatafeed_pb2.BfDeleteBarReq.FromString, ('bftrader.BfDatafeedService', 'DeleteContract'): bfdatafeed_pb2.BfDatafeedDeleteContractReq.FromString, ('bftrader.BfDatafeedService', 'DeleteTick'): bfdatafeed_pb2.BfDeleteTickReq.FromString, ('bftrader.BfDatafeedService', 'GetBar'): bfdatafeed_pb2.BfGetBarReq.FromString, ('bftrader.BfDatafeedService', 'GetContract'): bfdatafeed_pb2.BfDatafeedGetContractReq.FromString, ('bftrader.BfDatafeedService', 'GetTick'): bfdatafeed_pb2.BfGetTickReq.FromString, ('bftrader.BfDatafeedService', 'InsertBar'): bfdatafeed_pb2.BfBarData.FromString, ('bftrader.BfDatafeedService', 'InsertContract'): bfgateway_pb2.BfContractData.FromString, ('bftrader.BfDatafeedService', 'InsertTick'): bfgateway_pb2.BfTickData.FromString, ('bftrader.BfDatafeedService', 'Ping'): bfgateway_pb2.BfPingData.FromString, } response_serializers = { ('bftrader.BfDatafeedService', 'DeleteBar'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'DeleteContract'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'DeleteTick'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'GetBar'): bfdatafeed_pb2.BfBarData.SerializeToString, ('bftrader.BfDatafeedService', 'GetContract'): bfgateway_pb2.BfContractData.SerializeToString, ('bftrader.BfDatafeedService', 'GetTick'): bfgateway_pb2.BfTickData.SerializeToString, ('bftrader.BfDatafeedService', 'InsertBar'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'InsertContract'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'InsertTick'): bfgateway_pb2.BfVoid.SerializeToString, ('bftrader.BfDatafeedService', 'Ping'): bfgateway_pb2.BfPingData.SerializeToString, } method_implementations = { ('bftrader.BfDatafeedService', 'DeleteBar'): face_utilities.unary_unary_inline(servicer.DeleteBar), ('bftrader.BfDatafeedService', 'DeleteContract'): face_utilities.unary_unary_inline(servicer.DeleteContract), ('bftrader.BfDatafeedService', 'DeleteTick'): face_utilities.unary_unary_inline(servicer.DeleteTick), ('bftrader.BfDatafeedService', 'GetBar'): face_utilities.unary_stream_inline(servicer.GetBar), ('bftrader.BfDatafeedService', 'GetContract'): face_utilities.unary_stream_inline(servicer.GetContract), ('bftrader.BfDatafeedService', 'GetTick'): face_utilities.unary_stream_inline(servicer.GetTick), ('bftrader.BfDatafeedService', 'InsertBar'): face_utilities.unary_unary_inline(servicer.InsertBar), ('bftrader.BfDatafeedService', 'InsertContract'): face_utilities.unary_unary_inline(servicer.InsertContract), ('bftrader.BfDatafeedService', 'InsertTick'): face_utilities.unary_unary_inline(servicer.InsertTick), ('bftrader.BfDatafeedService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Query_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 import query_pb2 request_deserializers = { ('queryservice.Query', 'Begin'): query_pb2.BeginRequest.FromString, ('queryservice.Query', 'BeginExecute'): query_pb2.BeginExecuteRequest.FromString, ('queryservice.Query', 'BeginExecuteBatch'): query_pb2.BeginExecuteBatchRequest.FromString, ('queryservice.Query', 'Commit'): query_pb2.CommitRequest.FromString, ('queryservice.Query', 'Execute'): query_pb2.ExecuteRequest.FromString, ('queryservice.Query', 'ExecuteBatch'): query_pb2.ExecuteBatchRequest.FromString, ('queryservice.Query', 'Rollback'): query_pb2.RollbackRequest.FromString, ('queryservice.Query', 'SplitQuery'): query_pb2.SplitQueryRequest.FromString, ('queryservice.Query', 'StreamExecute'): query_pb2.StreamExecuteRequest.FromString, ('queryservice.Query', 'StreamHealth'): query_pb2.StreamHealthRequest.FromString, } response_serializers = { ('queryservice.Query', 'Begin'): query_pb2.BeginResponse.SerializeToString, ('queryservice.Query', 'BeginExecute'): query_pb2.BeginExecuteResponse.SerializeToString, ('queryservice.Query', 'BeginExecuteBatch'): query_pb2.BeginExecuteBatchResponse.SerializeToString, ('queryservice.Query', 'Commit'): query_pb2.CommitResponse.SerializeToString, ('queryservice.Query', 'Execute'): query_pb2.ExecuteResponse.SerializeToString, ('queryservice.Query', 'ExecuteBatch'): query_pb2.ExecuteBatchResponse.SerializeToString, ('queryservice.Query', 'Rollback'): query_pb2.RollbackResponse.SerializeToString, ('queryservice.Query', 'SplitQuery'): query_pb2.SplitQueryResponse.SerializeToString, ('queryservice.Query', 'StreamExecute'): query_pb2.StreamExecuteResponse.SerializeToString, ('queryservice.Query', 'StreamHealth'): query_pb2.StreamHealthResponse.SerializeToString, } method_implementations = { ('queryservice.Query', 'Begin'): face_utilities.unary_unary_inline(servicer.Begin), ('queryservice.Query', 'BeginExecute'): face_utilities.unary_unary_inline(servicer.BeginExecute), ('queryservice.Query', 'BeginExecuteBatch'): face_utilities.unary_unary_inline(servicer.BeginExecuteBatch), ('queryservice.Query', 'Commit'): face_utilities.unary_unary_inline(servicer.Commit), ('queryservice.Query', 'Execute'): face_utilities.unary_unary_inline(servicer.Execute), ('queryservice.Query', 'ExecuteBatch'): face_utilities.unary_unary_inline(servicer.ExecuteBatch), ('queryservice.Query', 'Rollback'): face_utilities.unary_unary_inline(servicer.Rollback), ('queryservice.Query', 'SplitQuery'): face_utilities.unary_unary_inline(servicer.SplitQuery), ('queryservice.Query', 'StreamExecute'): face_utilities.unary_stream_inline(servicer.StreamExecute), ('queryservice.Query', 'StreamHealth'): face_utilities.unary_stream_inline(servicer.StreamHealth), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_TestService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('TestService', 'DelayedMethod'): StandardRequest.FromString, ('TestService', 'DelayedStream'): StreamRequest.FromString, ('TestService', 'ExceptionMethod'): StandardRequest.FromString, ('TestService', 'NormalMethod'): StandardRequest.FromString, ('TestService', 'StreamInputMethod'): StandardRequest.FromString, ('TestService', 'StreamMethod'): StreamRequest.FromString, ('TestService', 'StreamStreamMethod'): StandardRequest.FromString, } response_serializers = { ('TestService', 'DelayedMethod'): StandardReply.SerializeToString, ('TestService', 'DelayedStream'): StandardReply.SerializeToString, ('TestService', 'ExceptionMethod'): StandardReply.SerializeToString, ('TestService', 'NormalMethod'): StandardReply.SerializeToString, ('TestService', 'StreamInputMethod'): StreamReply.SerializeToString, ('TestService', 'StreamMethod'): StandardReply.SerializeToString, ('TestService', 'StreamStreamMethod'): StandardReply.SerializeToString, } method_implementations = { ('TestService', 'DelayedMethod'): face_utilities.unary_unary_inline(servicer.DelayedMethod), ('TestService', 'DelayedStream'): face_utilities.unary_stream_inline(servicer.DelayedStream), ('TestService', 'ExceptionMethod'): face_utilities.unary_unary_inline(servicer.ExceptionMethod), ('TestService', 'NormalMethod'): face_utilities.unary_unary_inline(servicer.NormalMethod), ('TestService', 'StreamInputMethod'): face_utilities.stream_unary_inline(servicer.StreamInputMethod), ('TestService', 'StreamMethod'): face_utilities.unary_stream_inline(servicer.StreamMethod), ('TestService', 'StreamStreamMethod'): face_utilities.stream_stream_inline(servicer.StreamStreamMethod), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Agent_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('lbackgrpc.Agent', 'DoBackup'): shared__pb2.BackupCmdStream.FromString, ('lbackgrpc.Agent', 'DoRelocateGive'): shared__pb2.RelocateCmdGiveStream.FromString, ('lbackgrpc.Agent', 'DoRelocateTake'): shared__pb2.RelocateCmdTake.FromString, ('lbackgrpc.Agent', 'DoRestore'): shared__pb2.RestoreCmd.FromString, ('lbackgrpc.Agent', 'DoRm'): shared__pb2.RmCmd.FromString, } response_serializers = { ('lbackgrpc.Agent', 'DoBackup'): shared__pb2.BackupCmdStatus.SerializeToString, ('lbackgrpc.Agent', 'DoRelocateGive'): shared__pb2.RelocateCmdGiveStatus.SerializeToString, ('lbackgrpc.Agent', 'DoRelocateTake'): shared__pb2.RelocateCmdTakeStatus.SerializeToString, ('lbackgrpc.Agent', 'DoRestore'): shared__pb2.RestoreCmdStatus.SerializeToString, ('lbackgrpc.Agent', 'DoRm'): shared__pb2.RmCmdStatus.SerializeToString, } method_implementations = { ('lbackgrpc.Agent', 'DoBackup'): face_utilities.stream_unary_inline(servicer.DoBackup), ('lbackgrpc.Agent', 'DoRelocateGive'): face_utilities.stream_unary_inline(servicer.DoRelocateGive), ('lbackgrpc.Agent', 'DoRelocateTake'): face_utilities.unary_stream_inline(servicer.DoRelocateTake), ('lbackgrpc.Agent', 'DoRestore'): face_utilities.unary_stream_inline(servicer.DoRestore), ('lbackgrpc.Agent', 'DoRm'): face_utilities.unary_unary_inline(servicer.DoRm), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfDatafeedService_server( servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None ): import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfdatafeed_pb2 import bfdatafeed_pb2 import bfgateway_pb2 import bfgateway_pb2 request_deserializers = { ("bfdatafeed.BfDatafeedService", "GetBar"): bfdatafeed_pb2.BfGetBarReq.FromString, ("bfdatafeed.BfDatafeedService", "GetContract"): bfgateway_pb2.BfGetContractReq.FromString, ("bfdatafeed.BfDatafeedService", "GetTick"): bfdatafeed_pb2.BfGetTickReq.FromString, ("bfdatafeed.BfDatafeedService", "InsertBar"): bfdatafeed_pb2.BfBarData.FromString, ("bfdatafeed.BfDatafeedService", "InsertContract"): bfgateway_pb2.BfContractData.FromString, ("bfdatafeed.BfDatafeedService", "InsertTick"): bfgateway_pb2.BfTickData.FromString, ("bfdatafeed.BfDatafeedService", "Ping"): bfgateway_pb2.BfPingData.FromString, } response_serializers = { ("bfdatafeed.BfDatafeedService", "GetBar"): bfdatafeed_pb2.BfBarData.SerializeToString, ("bfdatafeed.BfDatafeedService", "GetContract"): bfgateway_pb2.BfContractData.SerializeToString, ("bfdatafeed.BfDatafeedService", "GetTick"): bfgateway_pb2.BfTickData.SerializeToString, ("bfdatafeed.BfDatafeedService", "InsertBar"): bfgateway_pb2.BfVoid.SerializeToString, ("bfdatafeed.BfDatafeedService", "InsertContract"): bfgateway_pb2.BfVoid.SerializeToString, ("bfdatafeed.BfDatafeedService", "InsertTick"): bfgateway_pb2.BfVoid.SerializeToString, ("bfdatafeed.BfDatafeedService", "Ping"): bfgateway_pb2.BfPingData.SerializeToString, } method_implementations = { ("bfdatafeed.BfDatafeedService", "GetBar"): face_utilities.unary_stream_inline(servicer.GetBar), ("bfdatafeed.BfDatafeedService", "GetContract"): face_utilities.unary_stream_inline(servicer.GetContract), ("bfdatafeed.BfDatafeedService", "GetTick"): face_utilities.unary_stream_inline(servicer.GetTick), ("bfdatafeed.BfDatafeedService", "InsertBar"): face_utilities.unary_unary_inline(servicer.InsertBar), ("bfdatafeed.BfDatafeedService", "InsertContract"): face_utilities.unary_unary_inline(servicer.InsertContract), ("bfdatafeed.BfDatafeedService", "InsertTick"): face_utilities.unary_unary_inline(servicer.InsertTick), ("bfdatafeed.BfDatafeedService", "Ping"): face_utilities.unary_unary_inline(servicer.Ping), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout, ) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_gRPCConfigOper_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 request_deserializers = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): ems_grpc_pb2.CliConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): ems_grpc_pb2.CommitArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): ems_grpc_pb2.CommitReplaceArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): ems_grpc_pb2.DiscardChangesArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): ems_grpc_pb2.ConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): ems_grpc_pb2.ConfigGetArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): ems_grpc_pb2.GetOperArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): ems_grpc_pb2.ConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): ems_grpc_pb2.ConfigArgs.FromString, } response_serializers = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): ems_grpc_pb2.CliConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): ems_grpc_pb2.CommitReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): ems_grpc_pb2.CommitReplaceReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): ems_grpc_pb2.DiscardChangesReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): ems_grpc_pb2.ConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): ems_grpc_pb2.ConfigGetReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): ems_grpc_pb2.GetOperReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): ems_grpc_pb2.ConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): ems_grpc_pb2.ConfigReply.SerializeToString, } method_implementations = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): face_utilities.unary_unary_inline(servicer.CliConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): face_utilities.unary_unary_inline(servicer.CommitConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): face_utilities.unary_unary_inline(servicer.CommitReplace), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): face_utilities.unary_unary_inline(servicer.ConfigDiscardChanges), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): face_utilities.unary_unary_inline(servicer.DeleteConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): face_utilities.unary_stream_inline(servicer.GetConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): face_utilities.unary_stream_inline(servicer.GetOper), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): face_utilities.unary_unary_inline(servicer.MergeConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): face_utilities.unary_unary_inline(servicer.ReplaceConfig), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_gRPCConfigOper_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 import cisco_ems_grpc_pb2 request_deserializers = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): cisco_ems_grpc_pb2.CliConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): cisco_ems_grpc_pb2.CommitArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): cisco_ems_grpc_pb2.CommitReplaceArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): cisco_ems_grpc_pb2.DiscardChangesArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): cisco_ems_grpc_pb2.ConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): cisco_ems_grpc_pb2.ConfigGetArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): cisco_ems_grpc_pb2.GetOperArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): cisco_ems_grpc_pb2.ConfigArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): cisco_ems_grpc_pb2.ConfigArgs.FromString, } response_serializers = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): cisco_ems_grpc_pb2.CliConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): cisco_ems_grpc_pb2.CommitReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): cisco_ems_grpc_pb2.CommitReplaceReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): cisco_ems_grpc_pb2.DiscardChangesReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): cisco_ems_grpc_pb2.ConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): cisco_ems_grpc_pb2.ConfigGetReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): cisco_ems_grpc_pb2.GetOperReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): cisco_ems_grpc_pb2.ConfigReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): cisco_ems_grpc_pb2.ConfigReply.SerializeToString, } method_implementations = { ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CliConfig'): face_utilities.unary_unary_inline(servicer.CliConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitConfig'): face_utilities.unary_unary_inline(servicer.CommitConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'CommitReplace'): face_utilities.unary_unary_inline(servicer.CommitReplace), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ConfigDiscardChanges'): face_utilities.unary_unary_inline(servicer.ConfigDiscardChanges), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'DeleteConfig'): face_utilities.unary_unary_inline(servicer.DeleteConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetConfig'): face_utilities.unary_stream_inline(servicer.GetConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'GetOper'): face_utilities.unary_stream_inline(servicer.GetOper), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'MergeConfig'): face_utilities.unary_unary_inline(servicer.MergeConfig), ('IOSXRExtensibleManagabilityService.gRPCConfigOper', 'ReplaceConfig'): face_utilities.unary_unary_inline(servicer.ReplaceConfig), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_RosBridgeService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('rosbridge_service.RosBridgeService', 'readCommandValues'): google_dot_protobuf_dot_empty__pb2.Empty.FromString, ('rosbridge_service.RosBridgeService', 'readEncoderValues'): google_dot_protobuf_dot_wrappers__pb2.StringValue.FromString, ('rosbridge_service.RosBridgeService', 'streamTwistValues'): TwistValue.FromString, ('rosbridge_service.RosBridgeService', 'writeTwistValue'): TwistValue.FromString, } response_serializers = { ('rosbridge_service.RosBridgeService', 'readCommandValues'): CommandValue.SerializeToString, ('rosbridge_service.RosBridgeService', 'readEncoderValues'): EncoderValue.SerializeToString, ('rosbridge_service.RosBridgeService', 'streamTwistValues'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('rosbridge_service.RosBridgeService', 'writeTwistValue'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, } method_implementations = { ('rosbridge_service.RosBridgeService', 'readCommandValues'): face_utilities.unary_stream_inline(servicer.readCommandValues), ('rosbridge_service.RosBridgeService', 'readEncoderValues'): face_utilities.unary_stream_inline(servicer.readEncoderValues), ('rosbridge_service.RosBridgeService', 'streamTwistValues'): face_utilities.stream_unary_inline(servicer.streamTwistValues), ('rosbridge_service.RosBridgeService', 'writeTwistValue'): face_utilities.unary_unary_inline(servicer.writeTwistValue), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Deployer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('deployment.Deployer', 'Deploy'): DeploymentRequest.FromString, ('deployment.Deployer', 'ListDeploymentEvents'): ListDeploymentEventsRequest.FromString, } response_serializers = { ('deployment.Deployer', 'Deploy'): DeploymentEvent.SerializeToString, ('deployment.Deployer', 'ListDeploymentEvents'): DeploymentEvent.SerializeToString, } method_implementations = { ('deployment.Deployer', 'Deploy'): face_utilities.unary_stream_inline(servicer.Deploy), ('deployment.Deployer', 'ListDeploymentEvents'): face_utilities.unary_stream_inline(servicer.ListDeploymentEvents), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Datastore_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('Datastore', 'init_connection'): UpdateReq.FromString, ('Datastore', 'update'): Request.FromString, } response_serializers = { ('Datastore', 'init_connection'): UpdateInfo.SerializeToString, ('Datastore', 'update'): Response.SerializeToString, } method_implementations = { ('Datastore', 'init_connection'): face_utilities.unary_stream_inline(servicer.init_connection), ('Datastore', 'update'): face_utilities.unary_unary_inline(servicer.update), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_RouteGuide_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('routeguide.RouteGuide', 'GetFeature'): Point.FromString, ('routeguide.RouteGuide', 'ListFeatures'): Rectangle.FromString, ('routeguide.RouteGuide', 'RecordRoute'): Point.FromString, ('routeguide.RouteGuide', 'RouteChat'): RouteNote.FromString, } response_serializers = { ('routeguide.RouteGuide', 'GetFeature'): Feature.SerializeToString, ('routeguide.RouteGuide', 'ListFeatures'): Feature.SerializeToString, ('routeguide.RouteGuide', 'RecordRoute'): RouteSummary.SerializeToString, ('routeguide.RouteGuide', 'RouteChat'): RouteNote.SerializeToString, } method_implementations = { ('routeguide.RouteGuide', 'GetFeature'): face_utilities.unary_unary_inline(servicer.GetFeature), ('routeguide.RouteGuide', 'ListFeatures'): face_utilities.unary_stream_inline(servicer.ListFeatures), ('routeguide.RouteGuide', 'RecordRoute'): face_utilities.stream_unary_inline(servicer.RecordRoute), ('routeguide.RouteGuide', 'RouteChat'): face_utilities.stream_stream_inline(servicer.RouteChat), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_RouteGuide_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 request_deserializers = { ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Point.FromString, ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Rectangle.FromString, ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.Point.FromString, ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.FromString, } response_serializers = { ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Feature.SerializeToString, ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Feature.SerializeToString, ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.RouteSummary.SerializeToString, ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.SerializeToString, } method_implementations = { ('routeguide.RouteGuide', 'GetFeature'): face_utilities.unary_unary_inline(servicer.GetFeature), ('routeguide.RouteGuide', 'ListFeatures'): face_utilities.unary_stream_inline(servicer.ListFeatures), ('routeguide.RouteGuide', 'RecordRoute'): face_utilities.stream_unary_inline(servicer.RecordRoute), ('routeguide.RouteGuide', 'RouteChat'): face_utilities.stream_stream_inline(servicer.RouteChat), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MonsterStorage_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" method_implementations = { ('MyGame.Example.MonsterStorage', 'GetMaxHitPoint'): face_utilities.stream_unary_inline(servicer.GetMaxHitPoint), ('MyGame.Example.MonsterStorage', 'GetMinMaxHitPoints'): face_utilities.unary_unary_inline(servicer.GetMinMaxHitPoints), ('MyGame.Example.MonsterStorage', 'Retrieve'): face_utilities.unary_stream_inline(servicer.Retrieve), ('MyGame.Example.MonsterStorage', 'Store'): face_utilities.unary_unary_inline(servicer.Store), } server_options = beta_implementations.server_options( thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfKvService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('bfkv.BfKvService', 'GetKv'): bfgateway__pb2.BfKvData.FromString, ('bfkv.BfKvService', 'Ping'): bfgateway__pb2.BfPingData.FromString, ('bfkv.BfKvService', 'PingStreamC'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'PingStreamCS'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'PingStreamS'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'SetKv'): bfgateway__pb2.BfKvData.FromString, } response_serializers = { ('bfkv.BfKvService', 'GetKv'): bfgateway__pb2.BfKvData.SerializeToString, ('bfkv.BfKvService', 'Ping'): bfgateway__pb2.BfPingData.SerializeToString, ('bfkv.BfKvService', 'PingStreamC'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'PingStreamCS'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'PingStreamS'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'SetKv'): bfgateway__pb2.BfVoid.SerializeToString, } method_implementations = { ('bfkv.BfKvService', 'GetKv'): face_utilities.unary_unary_inline(servicer.GetKv), ('bfkv.BfKvService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), ('bfkv.BfKvService', 'PingStreamC'): face_utilities.stream_unary_inline(servicer.PingStreamC), ('bfkv.BfKvService', 'PingStreamCS'): face_utilities.stream_stream_inline(servicer.PingStreamCS), ('bfkv.BfKvService', 'PingStreamS'): face_utilities.unary_stream_inline(servicer.PingStreamS), ('bfkv.BfKvService', 'SetKv'): face_utilities.unary_unary_inline(servicer.SetKv), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_StockHQService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_p2s'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_s2p'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_s2s'): query_struct.FromString, } response_serializers = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_p2s'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_s2p'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_s2s'): hq_struct.SerializeToString, } method_implementations = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): face_utilities.unary_unary_inline(servicer.QA_fetch_p2p), ('stock_hq.StockHQService', 'QA_fetch_p2s'): face_utilities.unary_stream_inline(servicer.QA_fetch_p2s), ('stock_hq.StockHQService', 'QA_fetch_s2p'): face_utilities.stream_unary_inline(servicer.QA_fetch_s2p), ('stock_hq.StockHQService', 'QA_fetch_s2s'): face_utilities.stream_stream_inline(servicer.QA_fetch_s2s), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_RecordReader_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('RecordReader', 'ProtoNames'): CompletionRequest.FromString, ('RecordReader', 'Query'): QueryRequest.FromString, ('RecordReader', 'Write'): WriteRequest.FromString, } response_serializers = { ('RecordReader', 'ProtoNames'): CompletionResponse.SerializeToString, ('RecordReader', 'Query'): QueryResponse.SerializeToString, ('RecordReader', 'Write'): WriteResponse.SerializeToString, } method_implementations = { ('RecordReader', 'ProtoNames'): face_utilities.unary_unary_inline(servicer.ProtoNames), ('RecordReader', 'Query'): face_utilities.unary_stream_inline(servicer.Query), ('RecordReader', 'Write'): face_utilities.unary_unary_inline(servicer.Write), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_PeopleSearch_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('people.PeopleSearch', 'FindByFirstCharacter'): Name.FromString, ('people.PeopleSearch', 'FindByFullName'): Name.FromString, } response_serializers = { ('people.PeopleSearch', 'FindByFirstCharacter'): PeopleInfo.SerializeToString, ('people.PeopleSearch', 'FindByFullName'): PeopleInfo.SerializeToString, } method_implementations = { ('people.PeopleSearch', 'FindByFirstCharacter'): face_utilities.unary_stream_inline(servicer.FindByFirstCharacter), ('people.PeopleSearch', 'FindByFullName'): face_utilities.unary_unary_inline(servicer.FindByFullName), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_JRService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('JRService.JRService', 'GetSongs'): SingerId.FromString, ('JRService.JRService', 'ListSongs'): SingerId.FromString, } response_serializers = { ('JRService.JRService', 'GetSongs'): Song.SerializeToString, ('JRService.JRService', 'ListSongs'): SongList.SerializeToString, } method_implementations = { ('JRService.JRService', 'GetSongs'): face_utilities.unary_stream_inline(servicer.GetSongs), ('JRService.JRService', 'ListSongs'): face_utilities.unary_unary_inline(servicer.ListSongs), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_JobsService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import jobs_pb2 request_deserializers = { ('jobs.JobsService', 'GetCount'): jobs_pb2.Void.FromString, ('jobs.JobsService', 'GetJobs'): jobs_pb2.SearchOptions.FromString, } response_serializers = { ('jobs.JobsService', 'GetCount'): jobs_pb2.Int.SerializeToString, ('jobs.JobsService', 'GetJobs'): jobs_pb2.JobInfo.SerializeToString, } method_implementations = { ('jobs.JobsService', 'GetCount'): face_utilities.unary_unary_inline(servicer.GetCount), ('jobs.JobsService', 'GetJobs'): face_utilities.unary_stream_inline(servicer.GetJobs), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_CustomerServer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('CustomerServer', 'AwaitTransaction'): AwaitReq.FromString, ('CustomerServer', 'EnrollInBusiness'): EnrollInBusinessRequest.FromString, ('CustomerServer', 'GetBalances'): BalanceRequest.FromString, } response_serializers = { ('CustomerServer', 'AwaitTransaction'): AwaitRsp.SerializeToString, ('CustomerServer', 'EnrollInBusiness'): EnrollInBusinessResponse.SerializeToString, ('CustomerServer', 'GetBalances'): Balances.SerializeToString, } method_implementations = { ('CustomerServer', 'AwaitTransaction'): face_utilities.unary_stream_inline(servicer.AwaitTransaction), ('CustomerServer', 'EnrollInBusiness'): face_utilities.unary_unary_inline(servicer.EnrollInBusiness), ('CustomerServer', 'GetBalances'): face_utilities.unary_unary_inline(servicer.GetBalances), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def setUp(self): self._servicer = _Servicer() self._method_implementations = { (_GROUP, _UNARY_UNARY): utilities.unary_unary_inline(self._servicer.unary_unary), (_GROUP, _UNARY_STREAM): utilities.unary_stream_inline(self._servicer.unary_stream), (_GROUP, _STREAM_UNARY): utilities.stream_unary_inline(self._servicer.stream_unary), (_GROUP, _STREAM_STREAM): utilities.stream_stream_inline(self._servicer.stream_stream), } self._cardinalities = { _UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, _UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, _STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, _STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, } self._server_options = implementations.server_options( thread_pool_size=test_constants.POOL_SIZE) self._server_credentials = implementations.ssl_server_credentials( [(resources.private_key(), resources.certificate_chain(),),]) self._client_credentials = implementations.ssl_client_credentials( resources.test_root_certificates(), None, None) self._stub_options = implementations.stub_options( thread_pool_size=test_constants.POOL_SIZE)
def beta_create_Image_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('imageprocess.Image', 'DetectElements'): ImgRequest.FromString, ('imageprocess.Image', 'Draw'): ImgRequest.FromString, ('imageprocess.Image', 'FindImage'): FindImgRequest.FromString, ('imageprocess.Image', 'OCR'): ImgRequest.FromString, } response_serializers = { ('imageprocess.Image', 'DetectElements'): ElementRect.SerializeToString, ('imageprocess.Image', 'Draw'): ImgReply.SerializeToString, ('imageprocess.Image', 'FindImage'): ElementPos.SerializeToString, ('imageprocess.Image', 'OCR'): TxtReply.SerializeToString, } method_implementations = { ('imageprocess.Image', 'DetectElements'): face_utilities.unary_stream_inline(servicer.DetectElements), ('imageprocess.Image', 'Draw'): face_utilities.unary_unary_inline(servicer.Draw), ('imageprocess.Image', 'FindImage'): face_utilities.unary_unary_inline(servicer.FindImage), ('imageprocess.Image', 'OCR'): face_utilities.unary_unary_inline(servicer.OCR), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Hello_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('grpcresolver.hello.Hello', 'Greeter'): HelloRequest.FromString, ('grpcresolver.hello.Hello', 'GreeterResponseStream'): HelloRequest.FromString, ('grpcresolver.hello.Hello', 'StreamGreeter'): HelloRequest.FromString, ('grpcresolver.hello.Hello', 'StreamGreeterResponseStream'): HelloRequest.FromString, } response_serializers = { ('grpcresolver.hello.Hello', 'Greeter'): HelloResponse.SerializeToString, ('grpcresolver.hello.Hello', 'GreeterResponseStream'): HelloResponse.SerializeToString, ('grpcresolver.hello.Hello', 'StreamGreeter'): HelloResponse.SerializeToString, ('grpcresolver.hello.Hello', 'StreamGreeterResponseStream'): HelloResponse.SerializeToString, } method_implementations = { ('grpcresolver.hello.Hello', 'Greeter'): face_utilities.unary_unary_inline(servicer.Greeter), ('grpcresolver.hello.Hello', 'GreeterResponseStream'): face_utilities.unary_stream_inline(servicer.GreeterResponseStream), ('grpcresolver.hello.Hello', 'StreamGreeter'): face_utilities.stream_unary_inline(servicer.StreamGreeter), ('grpcresolver.hello.Hello', 'StreamGreeterResponseStream'): face_utilities.stream_stream_inline(servicer.StreamGreeterResponseStream), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Store_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('store.Store', 'AddItem'): AddItemRequest.FromString, ('store.Store', 'AddItems'): AddItemRequest.FromString, ('store.Store', 'ListInventory'): Empty.FromString, ('store.Store', 'QueryQuantities'): QueryItemRequest.FromString, ('store.Store', 'QueryQuantity'): QueryItemRequest.FromString, ('store.Store', 'RemoveItem'): RemoveItemRequest.FromString, ('store.Store', 'RemoveItems'): RemoveItemRequest.FromString, } response_serializers = { ('store.Store', 'AddItem'): Empty.SerializeToString, ('store.Store', 'AddItems'): Empty.SerializeToString, ('store.Store', 'ListInventory'): QuantityResponse.SerializeToString, ('store.Store', 'QueryQuantities'): QuantityResponse.SerializeToString, ('store.Store', 'QueryQuantity'): QuantityResponse.SerializeToString, ('store.Store', 'RemoveItem'): RemoveItemResponse.SerializeToString, ('store.Store', 'RemoveItems'): RemoveItemResponse.SerializeToString, } method_implementations = { ('store.Store', 'AddItem'): face_utilities.unary_unary_inline(servicer.AddItem), ('store.Store', 'AddItems'): face_utilities.stream_unary_inline(servicer.AddItems), ('store.Store', 'ListInventory'): face_utilities.unary_stream_inline(servicer.ListInventory), ('store.Store', 'QueryQuantities'): face_utilities.stream_stream_inline(servicer.QueryQuantities), ('store.Store', 'QueryQuantity'): face_utilities.unary_unary_inline(servicer.QueryQuantity), ('store.Store', 'RemoveItem'): face_utilities.unary_unary_inline(servicer.RemoveItem), ('store.Store', 'RemoveItems'): face_utilities.stream_unary_inline(servicer.RemoveItems), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BrocadeTelemetryPhysicalInterfaceStatistics_service_server( servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('telemetry_intf_stats.BrocadeTelemetryPhysicalInterfaceStatistics_service', 'BrocadeTelemetryPhysicalInterfaceStatistics'): BrocadeTelemetryPhysicalInterfaceStatistics_request.FromString, } response_serializers = { ('telemetry_intf_stats.BrocadeTelemetryPhysicalInterfaceStatistics_service', 'BrocadeTelemetryPhysicalInterfaceStatistics'): BrocadeTelemetryPhysicalInterfaceStatistics_response.SerializeToString, } method_implementations = { ('telemetry_intf_stats.BrocadeTelemetryPhysicalInterfaceStatistics_service', 'BrocadeTelemetryPhysicalInterfaceStatistics'): face_utilities.unary_stream_inline( servicer.BrocadeTelemetryPhysicalInterfaceStatistics), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Watcher_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.watcher.v1.Watcher', 'Watch'): Request.FromString, } response_serializers = { ('google.watcher.v1.Watcher', 'Watch'): ChangeBatch.SerializeToString, } method_implementations = { ('google.watcher.v1.Watcher', 'Watch'): face_utilities.unary_stream_inline(servicer.Watch), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vtworker_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import vtworkerdata_pb2 import vtworkerdata_pb2 request_deserializers = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): vtworkerdata_pb2.ExecuteVtworkerCommandRequest.FromString, } response_serializers = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): vtworkerdata_pb2.ExecuteVtworkerCommandResponse.SerializeToString, } method_implementations = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): face_utilities.unary_stream_inline(servicer.ExecuteVtworkerCommand), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_SystemUtilizationService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): SystemUtilizationProfileRequest.FromString, } response_serializers = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): SystemUtilizationProfileResponse.SerializeToString, } method_implementations = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): face_utilities.unary_stream_inline( servicer.ListSystemUtilizationStatistics), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def setUp(self): self._servicer = _Servicer() self._method_implementations = { (_GROUP, _UNARY_UNARY): utilities.unary_unary_inline(self._servicer.unary_unary), (_GROUP, _UNARY_STREAM): utilities.unary_stream_inline(self._servicer.unary_stream), (_GROUP, _STREAM_UNARY): utilities.stream_unary_inline(self._servicer.stream_unary), (_GROUP, _STREAM_STREAM): utilities.stream_stream_inline(self._servicer.stream_stream), } self._cardinalities = { _UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, _UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, _STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, _STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, } self._server_options = implementations.server_options( thread_pool_size=test_constants.POOL_SIZE) self._server_credentials = implementations.ssl_server_credentials([ ( resources.private_key(), resources.certificate_chain(), ), ]) self._channel_credentials = implementations.ssl_channel_credentials( resources.test_root_certificates()) self._stub_options = implementations.stub_options( thread_pool_size=test_constants.POOL_SIZE)
def beta_create_OwstoniService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('btwan.OwstoniService', 'GetMetadataInfo'): InfoHash.FromString, ('btwan.OwstoniService', 'Index'): MetadataInfo.FromString, ('btwan.OwstoniService', 'Recv'): Void.FromString, ('btwan.OwstoniService', 'Search'): SearchReq.FromString, ('btwan.OwstoniService', 'Send'): Event.FromString, ('btwan.OwstoniService', 'SendInfoHash'): InfoHash.FromString, } response_serializers = { ('btwan.OwstoniService', 'GetMetadataInfo'): MetadataInfo.SerializeToString, ('btwan.OwstoniService', 'Index'): Void.SerializeToString, ('btwan.OwstoniService', 'Recv'): Event.SerializeToString, ('btwan.OwstoniService', 'Search'): SearchResp.SerializeToString, ('btwan.OwstoniService', 'Send'): Void.SerializeToString, ('btwan.OwstoniService', 'SendInfoHash'): Void.SerializeToString, } method_implementations = { ('btwan.OwstoniService', 'GetMetadataInfo'): face_utilities.unary_unary_inline(servicer.GetMetadataInfo), ('btwan.OwstoniService', 'Index'): face_utilities.unary_unary_inline(servicer.Index), ('btwan.OwstoniService', 'Recv'): face_utilities.unary_stream_inline(servicer.Recv), ('btwan.OwstoniService', 'Search'): face_utilities.unary_unary_inline(servicer.Search), ('btwan.OwstoniService', 'Send'): face_utilities.stream_unary_inline(servicer.Send), ('btwan.OwstoniService', 'SendInfoHash'): face_utilities.unary_unary_inline(servicer.SendInfoHash), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_IPython_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('ipython.IPython', 'cancel'): CancelRequest.FromString, ('ipython.IPython', 'complete'): CompletionRequest.FromString, ('ipython.IPython', 'execute'): ExecuteRequest.FromString, ('ipython.IPython', 'status'): StatusRequest.FromString, ('ipython.IPython', 'stop'): StopRequest.FromString, } response_serializers = { ('ipython.IPython', 'cancel'): CancelResponse.SerializeToString, ('ipython.IPython', 'complete'): CompletionResponse.SerializeToString, ('ipython.IPython', 'execute'): ExecuteResponse.SerializeToString, ('ipython.IPython', 'status'): StatusResponse.SerializeToString, ('ipython.IPython', 'stop'): StopResponse.SerializeToString, } method_implementations = { ('ipython.IPython', 'cancel'): face_utilities.unary_unary_inline(servicer.cancel), ('ipython.IPython', 'complete'): face_utilities.unary_unary_inline(servicer.complete), ('ipython.IPython', 'execute'): face_utilities.unary_stream_inline(servicer.execute), ('ipython.IPython', 'status'): face_utilities.unary_unary_inline(servicer.status), ('ipython.IPython', 'stop'): face_utilities.unary_unary_inline(servicer.stop), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_VariantService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('ga4gh.VariantService', 'GetCallSet'): GetCallSetRequest.FromString, ('ga4gh.VariantService', 'GetVariant'): GetVariantRequest.FromString, ('ga4gh.VariantService', 'GetVariantSet'): GetVariantSetRequest.FromString, ('ga4gh.VariantService', 'SearchCallSets'): SearchCallSetsRequest.FromString, ('ga4gh.VariantService', 'SearchVariantSets'): SearchVariantSetsRequest.FromString, ('ga4gh.VariantService', 'SearchVariants'): SearchVariantsRequest.FromString, } response_serializers = { ('ga4gh.VariantService', 'GetCallSet'): ga4gh_dot_variants__pb2.CallSet.SerializeToString, ('ga4gh.VariantService', 'GetVariant'): ga4gh_dot_variants__pb2.Variant.SerializeToString, ('ga4gh.VariantService', 'GetVariantSet'): ga4gh_dot_variants__pb2.VariantSet.SerializeToString, ('ga4gh.VariantService', 'SearchCallSets'): SearchCallSetsResponse.SerializeToString, ('ga4gh.VariantService', 'SearchVariantSets'): SearchVariantSetsResponse.SerializeToString, ('ga4gh.VariantService', 'SearchVariants'): ga4gh_dot_variants__pb2.Variant.SerializeToString, } method_implementations = { ('ga4gh.VariantService', 'GetCallSet'): face_utilities.unary_unary_inline(servicer.GetCallSet), ('ga4gh.VariantService', 'GetVariant'): face_utilities.unary_unary_inline(servicer.GetVariant), ('ga4gh.VariantService', 'GetVariantSet'): face_utilities.unary_unary_inline(servicer.GetVariantSet), ('ga4gh.VariantService', 'SearchCallSets'): face_utilities.unary_unary_inline(servicer.SearchCallSets), ('ga4gh.VariantService', 'SearchVariantSets'): face_utilities.unary_unary_inline(servicer.SearchVariantSets), ('ga4gh.VariantService', 'SearchVariants'): face_utilities.unary_stream_inline(servicer.SearchVariants), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_TReg_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('temp_reg.TReg', 'GetConfigs'): TId.FromString, ('temp_reg.TReg', 'SetConfigs'): TConfigs.FromString, ('temp_reg.TReg', 'StartRegulators'): TId.FromString, ('temp_reg.TReg', 'StopRegulators'): TId.FromString, ('temp_reg.TReg', 'StreamTemperatures'): Empty.FromString, } response_serializers = { ('temp_reg.TReg', 'GetConfigs'): TConfigs.SerializeToString, ('temp_reg.TReg', 'SetConfigs'): Empty.SerializeToString, ('temp_reg.TReg', 'StartRegulators'): Empty.SerializeToString, ('temp_reg.TReg', 'StopRegulators'): Empty.SerializeToString, ('temp_reg.TReg', 'StreamTemperatures'): Temperatures.SerializeToString, } method_implementations = { ('temp_reg.TReg', 'GetConfigs'): face_utilities.unary_unary_inline(servicer.GetConfigs), ('temp_reg.TReg', 'SetConfigs'): face_utilities.unary_unary_inline(servicer.SetConfigs), ('temp_reg.TReg', 'StartRegulators'): face_utilities.unary_unary_inline(servicer.StartRegulators), ('temp_reg.TReg', 'StopRegulators'): face_utilities.unary_unary_inline(servicer.StopRegulators), ('temp_reg.TReg', 'StreamTemperatures'): face_utilities.unary_stream_inline(servicer.StreamTemperatures), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Replicator_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('Replicator', 'delete'): Request.FromString, ('Replicator', 'get'): Request.FromString, ('Replicator', 'put'): Request.FromString, ('Replicator', 'sync'): SyncRequest.FromString, } response_serializers = { ('Replicator', 'delete'): Response.SerializeToString, ('Replicator', 'get'): Response.SerializeToString, ('Replicator', 'put'): Response.SerializeToString, ('Replicator', 'sync'): SyncOperation.SerializeToString, } method_implementations = { ('Replicator', 'delete'): face_utilities.unary_unary_inline(servicer.delete), ('Replicator', 'get'): face_utilities.unary_unary_inline(servicer.get), ('Replicator', 'put'): face_utilities.unary_unary_inline(servicer.put), ('Replicator', 'sync'): face_utilities.unary_stream_inline(servicer.sync), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Elastic_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('dstore.elastic.Elastic', 'ItemExport'): dstore_dot_elastic_dot_item_dot_item__export__pb2.Request.FromString, ('dstore.elastic.Elastic', 'ItemGet'): dstore_dot_elastic_dot_item_dot_item__get__pb2.Request.FromString, ('dstore.elastic.Elastic', 'ItemSuggest'): dstore_dot_elastic_dot_item_dot_item__suggest__pb2.Request.FromString, } response_serializers = { ('dstore.elastic.Elastic', 'ItemExport'): dstore_dot_elastic_dot_item_dot_item__export__pb2.Response. SerializeToString, ('dstore.elastic.Elastic', 'ItemGet'): dstore_dot_elastic_dot_item_dot_item__get__pb2.Response. SerializeToString, ('dstore.elastic.Elastic', 'ItemSuggest'): dstore_dot_elastic_dot_item_dot_item__suggest__pb2.Response. SerializeToString, } method_implementations = { ('dstore.elastic.Elastic', 'ItemExport'): face_utilities.unary_stream_inline(servicer.ItemExport), ('dstore.elastic.Elastic', 'ItemGet'): face_utilities.unary_stream_inline(servicer.ItemGet), ('dstore.elastic.Elastic', 'ItemSuggest'): face_utilities.unary_unary_inline(servicer.ItemSuggest), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_JavaForward_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('center.JavaForward', 'request_inquiry_forward'): request_inquiry.FromString, ('center.JavaForward', 'request_push_forward'): request_push.FromString, ('center.JavaForward', 'request_syn_forward'): request_syn.FromString, } response_serializers = { ('center.JavaForward', 'request_inquiry_forward'): response_inquiry.SerializeToString, ('center.JavaForward', 'request_push_forward'): response_push.SerializeToString, ('center.JavaForward', 'request_syn_forward'): response_syn.SerializeToString, } method_implementations = { ('center.JavaForward', 'request_inquiry_forward'): face_utilities.unary_stream_inline(servicer.request_inquiry_forward), ('center.JavaForward', 'request_push_forward'): face_utilities.unary_stream_inline(servicer.request_push_forward), ('center.JavaForward', 'request_syn_forward'): face_utilities.unary_stream_inline(servicer.request_syn_forward), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_gRPCExec_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 import ems_grpc_pb2 request_deserializers = { ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdJSONOutput'): ems_grpc_pb2.ShowCmdArgs.FromString, ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdTextOutput'): ems_grpc_pb2.ShowCmdArgs.FromString, } response_serializers = { ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdJSONOutput'): ems_grpc_pb2.ShowCmdJSONReply.SerializeToString, ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdTextOutput'): ems_grpc_pb2.ShowCmdTextReply.SerializeToString, } method_implementations = { ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdJSONOutput'): face_utilities.unary_stream_inline(servicer.ShowCmdJSONOutput), ('IOSXRExtensibleManagabilityService.gRPCExec', 'ShowCmdTextOutput'): face_utilities.unary_stream_inline(servicer.ShowCmdTextOutput), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfDatafeedService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('bfdatafeed.BfDatafeedService', 'CleanAll'): bfgateway__pb2.BfVoid.FromString, ('bfdatafeed.BfDatafeedService', 'DeleteBar'): BfDeleteBarReq.FromString, ('bfdatafeed.BfDatafeedService', 'DeleteContract'): BfDeleteContractReq.FromString, ('bfdatafeed.BfDatafeedService', 'DeleteTick'): BfDeleteTickReq.FromString, ('bfdatafeed.BfDatafeedService', 'GetBar'): BfGetBarReq.FromString, ('bfdatafeed.BfDatafeedService', 'GetContract'): bfgateway__pb2.BfGetContractReq.FromString, ('bfdatafeed.BfDatafeedService', 'GetTick'): BfGetTickReq.FromString, ('bfdatafeed.BfDatafeedService', 'InsertBar'): BfBarData.FromString, ('bfdatafeed.BfDatafeedService', 'InsertContract'): bfgateway__pb2.BfContractData.FromString, ('bfdatafeed.BfDatafeedService', 'InsertTick'): bfgateway__pb2.BfTickData.FromString, ('bfdatafeed.BfDatafeedService', 'Ping'): bfgateway__pb2.BfPingData.FromString, } response_serializers = { ('bfdatafeed.BfDatafeedService', 'CleanAll'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'DeleteBar'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'DeleteContract'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'DeleteTick'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'GetBar'): BfBarData.SerializeToString, ('bfdatafeed.BfDatafeedService', 'GetContract'): bfgateway__pb2.BfContractData.SerializeToString, ('bfdatafeed.BfDatafeedService', 'GetTick'): bfgateway__pb2.BfTickData.SerializeToString, ('bfdatafeed.BfDatafeedService', 'InsertBar'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'InsertContract'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'InsertTick'): bfgateway__pb2.BfVoid.SerializeToString, ('bfdatafeed.BfDatafeedService', 'Ping'): bfgateway__pb2.BfPingData.SerializeToString, } method_implementations = { ('bfdatafeed.BfDatafeedService', 'CleanAll'): face_utilities.unary_unary_inline(servicer.CleanAll), ('bfdatafeed.BfDatafeedService', 'DeleteBar'): face_utilities.unary_unary_inline(servicer.DeleteBar), ('bfdatafeed.BfDatafeedService', 'DeleteContract'): face_utilities.unary_unary_inline(servicer.DeleteContract), ('bfdatafeed.BfDatafeedService', 'DeleteTick'): face_utilities.unary_unary_inline(servicer.DeleteTick), ('bfdatafeed.BfDatafeedService', 'GetBar'): face_utilities.unary_stream_inline(servicer.GetBar), ('bfdatafeed.BfDatafeedService', 'GetContract'): face_utilities.unary_stream_inline(servicer.GetContract), ('bfdatafeed.BfDatafeedService', 'GetTick'): face_utilities.unary_stream_inline(servicer.GetTick), ('bfdatafeed.BfDatafeedService', 'InsertBar'): face_utilities.unary_unary_inline(servicer.InsertBar), ('bfdatafeed.BfDatafeedService', 'InsertContract'): face_utilities.unary_unary_inline(servicer.InsertContract), ('bfdatafeed.BfDatafeedService', 'InsertTick'): face_utilities.unary_unary_inline(servicer.InsertTick), ('bfdatafeed.BfDatafeedService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vtworker_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): vtworkerdata__pb2.ExecuteVtworkerCommandRequest.FromString, } response_serializers = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): vtworkerdata__pb2.ExecuteVtworkerCommandResponse.SerializeToString, } method_implementations = { ('vtworkerservice.Vtworker', 'ExecuteVtworkerCommand'): face_utilities.unary_stream_inline(servicer.ExecuteVtworkerCommand), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MovieService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import movie_service_pb2 import movie_service_pb2 import google.protobuf.empty_pb2 import movie_service_pb2 import google.protobuf.empty_pb2 import movie_service_pb2 import movie_service_pb2 import movie_service_pb2 import movie_service_pb2 import movie_service_pb2 import movie_service_pb2 import movie_service_pb2 request_deserializers = { ('movieservice.MovieService', 'GetMovieDetails'): movie_service_pb2.MovieRequest.FromString, ('movieservice.MovieService', 'ListAllMovies'): google.protobuf.empty_pb2.Empty.FromString, ('movieservice.MovieService', 'ListAllMoviesServerStreaming'): google.protobuf.empty_pb2.Empty.FromString, ('movieservice.MovieService', 'ListMoviesBidirectionalStreaming'): movie_service_pb2.MovieRequest.FromString, ('movieservice.MovieService', 'ListMoviesClientToServerStreaming'): movie_service_pb2.MovieRequest.FromString, ('movieservice.MovieService', 'ListMoviesServerToClientStreaming'): movie_service_pb2.MoviesInTheaterRequest.FromString, } response_serializers = { ('movieservice.MovieService', 'GetMovieDetails'): movie_service_pb2.Movie.SerializeToString, ('movieservice.MovieService', 'ListAllMovies'): movie_service_pb2.MoviesInTheaterResponse.SerializeToString, ('movieservice.MovieService', 'ListAllMoviesServerStreaming'): movie_service_pb2.Movie.SerializeToString, ('movieservice.MovieService', 'ListMoviesBidirectionalStreaming'): movie_service_pb2.Movie.SerializeToString, ('movieservice.MovieService', 'ListMoviesClientToServerStreaming'): movie_service_pb2.MoviesInTheaterResponse.SerializeToString, ('movieservice.MovieService', 'ListMoviesServerToClientStreaming'): movie_service_pb2.Movie.SerializeToString, } method_implementations = { ('movieservice.MovieService', 'GetMovieDetails'): face_utilities.unary_unary_inline(servicer.GetMovieDetails), ('movieservice.MovieService', 'ListAllMovies'): face_utilities.unary_unary_inline(servicer.ListAllMovies), ('movieservice.MovieService', 'ListAllMoviesServerStreaming'): face_utilities.unary_stream_inline(servicer.ListAllMoviesServerStreaming), ('movieservice.MovieService', 'ListMoviesBidirectionalStreaming'): face_utilities.stream_stream_inline(servicer.ListMoviesBidirectionalStreaming), ('movieservice.MovieService', 'ListMoviesClientToServerStreaming'): face_utilities.stream_unary_inline(servicer.ListMoviesClientToServerStreaming), ('movieservice.MovieService', 'ListMoviesServerToClientStreaming'): face_utilities.unary_stream_inline(servicer.ListMoviesServerToClientStreaming), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Google_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import search_pb2 import search_pb2 request_deserializers = { ('Google', 'Search'): search_pb2.Request.FromString, } response_serializers = { ('Google', 'Search'): search_pb2.Results.SerializeToString, } method_implementations = { ('Google', 'Search'): face_utilities.unary_stream_inline(servicer.Search), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfGatewayService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import bftrader_pb2 import google.protobuf.any_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 request_deserializers = { ('bftrader.bfgateway.BfGatewayService', 'CancelOrder'): bftrader_pb2.BfCancelOrderReq.FromString, ('bftrader.bfgateway.BfGatewayService', 'Connect'): bftrader_pb2.BfConnectReq.FromString, ('bftrader.bfgateway.BfGatewayService', 'Disconnect'): bftrader_pb2.BfVoid.FromString, ('bftrader.bfgateway.BfGatewayService', 'GetContract'): bftrader_pb2.BfGetContractReq.FromString, ('bftrader.bfgateway.BfGatewayService', 'Ping'): bftrader_pb2.BfPingData.FromString, ('bftrader.bfgateway.BfGatewayService', 'QueryAccount'): bftrader_pb2.BfVoid.FromString, ('bftrader.bfgateway.BfGatewayService', 'QueryPosition'): bftrader_pb2.BfVoid.FromString, ('bftrader.bfgateway.BfGatewayService', 'SendOrder'): bftrader_pb2.BfSendOrderReq.FromString, } response_serializers = { ('bftrader.bfgateway.BfGatewayService', 'CancelOrder'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'Connect'): google.protobuf.any_pb2.Any.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'Disconnect'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'GetContract'): bftrader_pb2.BfContractData.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'Ping'): bftrader_pb2.BfPingData.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'QueryAccount'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'QueryPosition'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfgateway.BfGatewayService', 'SendOrder'): bftrader_pb2.BfSendOrderResp.SerializeToString, } method_implementations = { ('bftrader.bfgateway.BfGatewayService', 'CancelOrder'): face_utilities.unary_unary_inline(servicer.CancelOrder), ('bftrader.bfgateway.BfGatewayService', 'Connect'): face_utilities.unary_stream_inline(servicer.Connect), ('bftrader.bfgateway.BfGatewayService', 'Disconnect'): face_utilities.unary_unary_inline(servicer.Disconnect), ('bftrader.bfgateway.BfGatewayService', 'GetContract'): face_utilities.unary_unary_inline(servicer.GetContract), ('bftrader.bfgateway.BfGatewayService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), ('bftrader.bfgateway.BfGatewayService', 'QueryAccount'): face_utilities.unary_unary_inline(servicer.QueryAccount), ('bftrader.bfgateway.BfGatewayService', 'QueryPosition'): face_utilities.unary_unary_inline(servicer.QueryPosition), ('bftrader.bfgateway.BfGatewayService', 'SendOrder'): face_utilities.unary_unary_inline(servicer.SendOrder), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_JobsService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import jobs_pb2 request_deserializers = { ('jobs.JobsService', 'GetCount'): jobs_pb2.Void.FromString, ('jobs.JobsService', 'GetJobs'): jobs_pb2.SearchOptions.FromString, } response_serializers = { ('jobs.JobsService', 'GetCount'): jobs_pb2.Int.SerializeToString, ('jobs.JobsService', 'GetJobs'): jobs_pb2.JobInfo.SerializeToString, } method_implementations = { ('jobs.JobsService', 'GetCount'): face_utilities.unary_unary_inline(servicer.GetCount), ('jobs.JobsService', 'GetJobs'): face_utilities.unary_stream_inline(servicer.GetJobs), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def setUp(self): self._servicer = _Servicer() method_implementations = { (_GROUP, _UNARY_UNARY): utilities.unary_unary_inline(self._servicer.unary_unary), (_GROUP, _UNARY_STREAM): utilities.unary_stream_inline(self._servicer.unary_stream), (_GROUP, _STREAM_UNARY): utilities.stream_unary_inline(self._servicer.stream_unary), (_GROUP, _STREAM_STREAM): utilities.stream_stream_inline(self._servicer.stream_stream), } cardinalities = { _UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, _UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, _STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, _STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, } server_options = implementations.server_options( thread_pool_size=test_constants.POOL_SIZE) self._server = implementations.server( method_implementations, options=server_options) server_credentials = implementations.ssl_server_credentials([ ( resources.private_key(), resources.certificate_chain(), ), ]) port = self._server.add_secure_port('[::]:0', server_credentials) self._server.start() self._channel_credentials = implementations.ssl_channel_credentials( resources.test_root_certificates()) self._call_credentials = implementations.metadata_call_credentials( _metadata_plugin) channel = test_utilities.not_really_secure_channel( 'localhost', port, self._channel_credentials, _SERVER_HOST_OVERRIDE) stub_options = implementations.stub_options( thread_pool_size=test_constants.POOL_SIZE) self._dynamic_stub = implementations.dynamic_stub( channel, _GROUP, cardinalities, options=stub_options)
def beta_create_Translator_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('srecon.Translator', 'AllTranslations'): AllTranslationsRequest.FromString, ('srecon.Translator', 'Translate'): TranslationRequest.FromString, } response_serializers = { ('srecon.Translator', 'AllTranslations'): AllTranslationsReply.SerializeToString, ('srecon.Translator', 'Translate'): TranslationReply.SerializeToString, } method_implementations = { ('srecon.Translator', 'AllTranslations'): face_utilities.unary_stream_inline(servicer.AllTranslations), ('srecon.Translator', 'Translate'): face_utilities.unary_unary_inline(servicer.Translate), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vtctl_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import vtctldata_pb2 import vtctldata_pb2 request_deserializers = { ("vtctlservice.Vtctl", "ExecuteVtctlCommand"): vtctldata_pb2.ExecuteVtctlCommandRequest.FromString } response_serializers = { ("vtctlservice.Vtctl", "ExecuteVtctlCommand"): vtctldata_pb2.ExecuteVtctlCommandResponse.SerializeToString } method_implementations = { ("vtctlservice.Vtctl", "ExecuteVtctlCommand"): face_utilities.unary_stream_inline(servicer.ExecuteVtctlCommand) } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout, ) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfCtaService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('bfcta.BfCtaService', 'ConnectPush'): bfgateway__pb2.BfConnectPushReq.FromString, ('bfcta.BfCtaService', 'DisconnectPush'): bfgateway__pb2.BfVoid.FromString, ('bfcta.BfCtaService', 'Ping'): bfgateway__pb2.BfPingData.FromString, ('bfcta.BfCtaService', 'Start'): bfgateway__pb2.BfVoid.FromString, ('bfcta.BfCtaService', 'Stop'): bfgateway__pb2.BfVoid.FromString, } response_serializers = { ('bfcta.BfCtaService', 'ConnectPush'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfcta.BfCtaService', 'DisconnectPush'): bfgateway__pb2.BfVoid.SerializeToString, ('bfcta.BfCtaService', 'Ping'): bfgateway__pb2.BfPingData.SerializeToString, ('bfcta.BfCtaService', 'Start'): bfgateway__pb2.BfVoid.SerializeToString, ('bfcta.BfCtaService', 'Stop'): bfgateway__pb2.BfVoid.SerializeToString, } method_implementations = { ('bfcta.BfCtaService', 'ConnectPush'): face_utilities.unary_stream_inline(servicer.ConnectPush), ('bfcta.BfCtaService', 'DisconnectPush'): face_utilities.unary_unary_inline(servicer.DisconnectPush), ('bfcta.BfCtaService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), ('bfcta.BfCtaService', 'Start'): face_utilities.unary_unary_inline(servicer.Start), ('bfcta.BfCtaService', 'Stop'): face_utilities.unary_unary_inline(servicer.Stop), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_ZfsRpc_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 import zfs_pb2 request_deserializers = { ('zfs.ZfsRpc', 'CreateFile'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'Fetch'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'FetchDir'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'GetFileStat'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'MakeDir'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'RemoveDir'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'RemoveFile'): zfs_pb2.FilePath.FromString, ('zfs.ZfsRpc', 'Rename'): zfs_pb2.RenameMsg.FromString, ('zfs.ZfsRpc', 'SetFileStat'): zfs_pb2.FileStat.FromString, ('zfs.ZfsRpc', 'Store'): zfs_pb2.FileDataBlock.FromString, ('zfs.ZfsRpc', 'TestAuth'): zfs_pb2.TestAuthRequest.FromString, } response_serializers = { ('zfs.ZfsRpc', 'CreateFile'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'Fetch'): zfs_pb2.FileDataBlock.SerializeToString, ('zfs.ZfsRpc', 'FetchDir'): zfs_pb2.DirListBlock.SerializeToString, ('zfs.ZfsRpc', 'GetFileStat'): zfs_pb2.FileStat.SerializeToString, ('zfs.ZfsRpc', 'MakeDir'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'RemoveDir'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'RemoveFile'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'Rename'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'SetFileStat'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'Store'): zfs_pb2.StdReply.SerializeToString, ('zfs.ZfsRpc', 'TestAuth'): zfs_pb2.TestAuthReply.SerializeToString, } method_implementations = { ('zfs.ZfsRpc', 'CreateFile'): face_utilities.unary_unary_inline(servicer.CreateFile), ('zfs.ZfsRpc', 'Fetch'): face_utilities.unary_stream_inline(servicer.Fetch), ('zfs.ZfsRpc', 'FetchDir'): face_utilities.unary_stream_inline(servicer.FetchDir), ('zfs.ZfsRpc', 'GetFileStat'): face_utilities.unary_unary_inline(servicer.GetFileStat), ('zfs.ZfsRpc', 'MakeDir'): face_utilities.unary_unary_inline(servicer.MakeDir), ('zfs.ZfsRpc', 'RemoveDir'): face_utilities.unary_unary_inline(servicer.RemoveDir), ('zfs.ZfsRpc', 'RemoveFile'): face_utilities.unary_unary_inline(servicer.RemoveFile), ('zfs.ZfsRpc', 'Rename'): face_utilities.unary_unary_inline(servicer.Rename), ('zfs.ZfsRpc', 'SetFileStat'): face_utilities.unary_unary_inline(servicer.SetFileStat), ('zfs.ZfsRpc', 'Store'): face_utilities.stream_unary_inline(servicer.Store), ('zfs.ZfsRpc', 'TestAuth'): face_utilities.unary_unary_inline(servicer.TestAuth), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)