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)
