def beta_create_AtomicBroadcast_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('atomicbroadcast.AtomicBroadcast', 'Broadcast'):
BroadcastMessage.FromString,
('atomicbroadcast.AtomicBroadcast', 'Deliver'):
DeliverUpdate.FromString,
}
response_serializers = {
('atomicbroadcast.AtomicBroadcast', 'Broadcast'):
BroadcastResponse.SerializeToString,
('atomicbroadcast.AtomicBroadcast', 'Deliver'):
DeliverResponse.SerializeToString,
}
method_implementations = {
('atomicbroadcast.AtomicBroadcast', 'Broadcast'):
face_utilities.stream_stream_inline(servicer.Broadcast),
('atomicbroadcast.AtomicBroadcast', 'Deliver'):
face_utilities.stream_stream_inline(servicer.Deliver),
}
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_RouteDiscoveryService_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 = {
('envoy.api.v2.RouteDiscoveryService', 'DeltaRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DeltaDiscoveryRequest.
FromString,
('envoy.api.v2.RouteDiscoveryService', 'FetchRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DiscoveryRequest.
FromString,
('envoy.api.v2.RouteDiscoveryService', 'StreamRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DiscoveryRequest.
FromString,
}
response_serializers = {
('envoy.api.v2.RouteDiscoveryService', 'DeltaRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DeltaDiscoveryResponse.
SerializeToString,
('envoy.api.v2.RouteDiscoveryService', 'FetchRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DiscoveryResponse.
SerializeToString,
('envoy.api.v2.RouteDiscoveryService', 'StreamRoutes'):
envoy_dot_api_dot_v2_dot_discovery__pb2.DiscoveryResponse.
SerializeToString,
}
method_implementations = {
('envoy.api.v2.RouteDiscoveryService', 'DeltaRoutes'):
face_utilities.stream_stream_inline(servicer.DeltaRoutes),
('envoy.api.v2.RouteDiscoveryService', 'FetchRoutes'):
face_utilities.unary_unary_inline(servicer.FetchRoutes),
('envoy.api.v2.RouteDiscoveryService', 'StreamRoutes'):
face_utilities.stream_stream_inline(servicer.StreamRoutes),
}
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_AtomicBroadcast_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
request_deserializers = {
('orderer.AtomicBroadcast', 'Broadcast'): common_dot_common__pb2.Envelope.FromString,
('orderer.AtomicBroadcast', 'Deliver'): SeekInfo.FromString,
}
response_serializers = {
('orderer.AtomicBroadcast', 'Broadcast'): BroadcastResponse.SerializeToString,
('orderer.AtomicBroadcast', 'Deliver'): DeliverResponse.SerializeToString,
}
method_implementations = {
('orderer.AtomicBroadcast', 'Broadcast'): face_utilities.stream_stream_inline(servicer.Broadcast),
('orderer.AtomicBroadcast', 'Deliver'): face_utilities.stream_stream_inline(servicer.Deliver),
}
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_Events_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
import events_pb2
import events_pb2
request_deserializers = {
('protos.Events', 'Chat'): events_pb2.Event.FromString,
}
response_serializers = {
('protos.Events', 'Chat'): events_pb2.Event.SerializeToString,
}
method_implementations = {
('protos.Events', 'Chat'):
face_utilities.stream_stream_inline(servicer.Chat),
}
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_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 _create_server(self, config):
if config.server_type == control_pb2.SYNC_SERVER:
servicer = benchmark_server.BenchmarkServer()
server = services_pb2.beta_create_BenchmarkService_server(servicer)
elif config.server_type == control_pb2.ASYNC_GENERIC_SERVER:
resp_size = config.payload_config.bytebuf_params.resp_size
servicer = benchmark_server.GenericBenchmarkServer(resp_size)
method_implementations = {
('grpc.testing.BenchmarkService', 'StreamingCall'):
utilities.stream_stream_inline(servicer.StreamingCall),
('grpc.testing.BenchmarkService', 'UnaryCall'):
utilities.unary_unary_inline(servicer.UnaryCall),
}
server = implementations.server(method_implementations)
else:
raise Exception('Unsupported server type {}'.format(
config.server_type))
if config.HasField('security_params'): # Use SSL
server_creds = implementations.ssl_server_credentials([
(resources.private_key(), resources.certificate_chain())
])
port = server.add_secure_port('[::]:{}'.format(config.port),
server_creds)
else:
port = server.add_insecure_port('[::]:{}'.format(config.port))
return (server, port)
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_Events_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 = {
('hfc.protos.peer.Events', 'Chat'): Event.FromString,
}
response_serializers = {
('hfc.protos.peer.Events', 'Chat'): Event.SerializeToString,
}
method_implementations = {
('hfc.protos.peer.Events', 'Chat'):
face_utilities.stream_stream_inline(servicer.Chat),
}
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_Listener_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('SpeechToText.Listener', 'DoConfig'): ConfigSTT.FromString,
('SpeechToText.Listener', 'DoSpeechToText'): SpeechChunk.FromString,
}
response_serializers = {
('SpeechToText.Listener', 'DoConfig'):
ConfigResult.SerializeToString,
('SpeechToText.Listener', 'DoSpeechToText'):
TranscriptChunk.SerializeToString,
}
method_implementations = {
('SpeechToText.Listener', 'DoConfig'):
face_utilities.unary_unary_inline(servicer.DoConfig),
('SpeechToText.Listener', 'DoSpeechToText'):
face_utilities.stream_stream_inline(servicer.DoSpeechToText),
}
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_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 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 _create_server(self, config):
if config.server_type == control_pb2.SYNC_SERVER:
servicer = benchmark_server.BenchmarkServer()
server = services_pb2.beta_create_BenchmarkService_server(servicer)
elif config.server_type == control_pb2.ASYNC_GENERIC_SERVER:
resp_size = config.payload_config.bytebuf_params.resp_size
servicer = benchmark_server.GenericBenchmarkServer(resp_size)
method_implementations = {
('grpc.testing.BenchmarkService', 'StreamingCall'):
utilities.stream_stream_inline(servicer.StreamingCall),
('grpc.testing.BenchmarkService', 'UnaryCall'):
utilities.unary_unary_inline(servicer.UnaryCall),
}
server = implementations.server(method_implementations)
else:
raise Exception('Unsupported server type {}'.format(config.server_type))
if config.HasField('security_params'): # Use SSL
server_creds = implementations.ssl_server_credentials([(
resources.private_key(), resources.certificate_chain())])
port = server.add_secure_port('[::]:{}'.format(config.port), server_creds)
else:
port = server.add_insecure_port('[::]:{}'.format(config.port))
return (server, port)
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_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_GNURadioLink_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 = {
('grgrpc.GNURadioLink', 'PublishData'): GRData.FromString,
('grgrpc.GNURadioLink', 'RequestData'): StatusData.FromString,
}
response_serializers = {
('grgrpc.GNURadioLink', 'PublishData'): StatusData.SerializeToString,
('grgrpc.GNURadioLink', 'RequestData'): GRData.SerializeToString,
}
method_implementations = {
('grgrpc.GNURadioLink', 'PublishData'): face_utilities.stream_stream_inline(servicer.PublishData),
('grgrpc.GNURadioLink', 'RequestData'): face_utilities.stream_stream_inline(servicer.RequestData),
}
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_AtomicBroadcast_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 = {
('orderer.AtomicBroadcast', 'Broadcast'): hfc_dot_protos_dot_common_dot_common__pb2.Envelope.FromString,
('orderer.AtomicBroadcast', 'Deliver'): hfc_dot_protos_dot_common_dot_common__pb2.Envelope.FromString,
}
response_serializers = {
('orderer.AtomicBroadcast', 'Broadcast'): BroadcastResponse.SerializeToString,
('orderer.AtomicBroadcast', 'Deliver'): DeliverResponse.SerializeToString,
}
method_implementations = {
('orderer.AtomicBroadcast', 'Broadcast'): face_utilities.stream_stream_inline(servicer.Broadcast),
('orderer.AtomicBroadcast', 'Deliver'): face_utilities.stream_stream_inline(servicer.Deliver),
}
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_AtomicBroadcast_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 = {
('orderer.AtomicBroadcast', 'Broadcast'): common_dot_common__pb2.Envelope.FromString,
('orderer.AtomicBroadcast', 'Deliver'): common_dot_common__pb2.Envelope.FromString,
}
response_serializers = {
('orderer.AtomicBroadcast', 'Broadcast'): BroadcastResponse.SerializeToString,
('orderer.AtomicBroadcast', 'Deliver'): DeliverResponse.SerializeToString,
}
method_implementations = {
('orderer.AtomicBroadcast', 'Broadcast'): face_utilities.stream_stream_inline(servicer.Broadcast),
('orderer.AtomicBroadcast', 'Deliver'): face_utilities.stream_stream_inline(servicer.Deliver),
}
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_ChaincodeSupport_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
request_deserializers = {
('protos.ChaincodeSupport', 'Register'): ChaincodeMessage.FromString,
}
response_serializers = {
('protos.ChaincodeSupport', 'Register'): ChaincodeMessage.SerializeToString,
}
method_implementations = {
('protos.ChaincodeSupport', 'Register'): face_utilities.stream_stream_inline(servicer.Register),
}
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_Connector_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 = {
('qlik.sse.Connector', 'EvaluateScript'): BundledRows.FromString,
('qlik.sse.Connector', 'ExecuteFunction'): BundledRows.FromString,
('qlik.sse.Connector', 'GetCapabilities'): Empty.FromString,
}
response_serializers = {
('qlik.sse.Connector', 'EvaluateScript'):
BundledRows.SerializeToString,
('qlik.sse.Connector', 'ExecuteFunction'):
BundledRows.SerializeToString,
('qlik.sse.Connector', 'GetCapabilities'):
Capabilities.SerializeToString,
}
method_implementations = {
('qlik.sse.Connector', 'EvaluateScript'):
face_utilities.stream_stream_inline(servicer.EvaluateScript),
('qlik.sse.Connector', 'ExecuteFunction'):
face_utilities.stream_stream_inline(servicer.ExecuteFunction),
('qlik.sse.Connector', 'GetCapabilities'):
face_utilities.unary_unary_inline(servicer.GetCapabilities),
}
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_Events_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
import events_pb2
import events_pb2
request_deserializers = {
('protos.Events', 'Chat'): events_pb2.Event.FromString,
}
response_serializers = {
('protos.Events', 'Chat'): events_pb2.Event.SerializeToString,
}
method_implementations = {
('protos.Events', 'Chat'): face_utilities.stream_stream_inline(servicer.Chat),
}
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_Subscriber_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 = {
('predix.eventhub.Subscriber', 'receive'): SubscriptionRequest.FromString,
('predix.eventhub.Subscriber', 'receiveWithAcks'): SubscriptionResponse.FromString,
('predix.eventhub.Subscriber', 'subscribe'): SubscriptionAcks.FromString,
}
response_serializers = {
('predix.eventhub.Subscriber', 'receive'): Message.SerializeToString,
('predix.eventhub.Subscriber', 'receiveWithAcks'): Message.SerializeToString,
('predix.eventhub.Subscriber', 'subscribe'): SubscriptionMessage.SerializeToString,
}
method_implementations = {
('predix.eventhub.Subscriber', 'receive'): face_utilities.unary_stream_inline(servicer.receive),
('predix.eventhub.Subscriber', 'receiveWithAcks'): face_utilities.stream_stream_inline(servicer.receiveWithAcks),
('predix.eventhub.Subscriber', 'subscribe'): face_utilities.stream_stream_inline(servicer.subscribe),
}
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_Engine_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.engine.Engine', 'CreateUniqueID'):
dstore_dot_values__pb2.StringValue.FromString,
('dstore.engine.Engine', 'ExecBatch'):
dstore_dot_engine_dot_procedure__pb2.Call.FromString,
('dstore.engine.Engine', 'ExecProcedure'):
dstore_dot_engine_dot_procedure__pb2.Call.FromString,
('dstore.engine.Engine', 'IsValidUniqueID'):
dstore_dot_values__pb2.StringValue.FromString,
}
response_serializers = {
('dstore.engine.Engine', 'CreateUniqueID'):
dstore_dot_values__pb2.StringValue.SerializeToString,
('dstore.engine.Engine', 'ExecBatch'):
dstore_dot_engine_dot_procedure__pb2.Response.SerializeToString,
('dstore.engine.Engine', 'ExecProcedure'):
dstore_dot_engine_dot_procedure__pb2.Response.SerializeToString,
('dstore.engine.Engine', 'IsValidUniqueID'):
dstore_dot_values__pb2.BooleanValue.SerializeToString,
}
method_implementations = {
('dstore.engine.Engine', 'CreateUniqueID'):
face_utilities.unary_unary_inline(servicer.CreateUniqueID),
('dstore.engine.Engine', 'ExecBatch'):
face_utilities.stream_stream_inline(servicer.ExecBatch),
('dstore.engine.Engine', 'ExecProcedure'):
face_utilities.unary_stream_inline(servicer.ExecProcedure),
('dstore.engine.Engine', 'IsValidUniqueID'):
face_utilities.unary_unary_inline(servicer.IsValidUniqueID),
}
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_TaskManager_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 = {
('gogrpcspec.TaskManager', 'AddTask'): Task.FromString,
('gogrpcspec.TaskManager', 'AddTasks'): Task.FromString,
('gogrpcspec.TaskManager', 'ChangeToDone'): Task.FromString,
('gogrpcspec.TaskManager', 'GetSummary'): Employee.FromString,
('gogrpcspec.TaskManager', 'GetTasks'): Employee.FromString,
}
response_serializers = {
('gogrpcspec.TaskManager', 'AddTask'):
SpecificSummary.SerializeToString,
('gogrpcspec.TaskManager', 'AddTasks'): Summary.SerializeToString,
('gogrpcspec.TaskManager', 'ChangeToDone'): Task.SerializeToString,
('gogrpcspec.TaskManager', 'GetSummary'):
SpecificSummary.SerializeToString,
('gogrpcspec.TaskManager', 'GetTasks'): Task.SerializeToString,
}
method_implementations = {
('gogrpcspec.TaskManager', 'AddTask'):
face_utilities.unary_unary_inline(servicer.AddTask),
('gogrpcspec.TaskManager', 'AddTasks'):
face_utilities.stream_unary_inline(servicer.AddTasks),
('gogrpcspec.TaskManager', 'ChangeToDone'):
face_utilities.stream_stream_inline(servicer.ChangeToDone),
('gogrpcspec.TaskManager', 'GetSummary'):
face_utilities.unary_unary_inline(servicer.GetSummary),
('gogrpcspec.TaskManager', 'GetTasks'):
face_utilities.unary_stream_inline(servicer.GetTasks),
}
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_Events_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 = {
('protos.Events', 'Chat'): Event.FromString,
}
response_serializers = {
('protos.Events', 'Chat'): Event.SerializeToString,
}
method_implementations = {
('protos.Events', 'Chat'): face_utilities.stream_stream_inline(servicer.Chat),
}
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_Calculator_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 = {
('Calculator', 'Chat'):
Number.FromString,
('Calculator', 'ReceiveEvents'):
google_dot_protobuf_dot_empty__pb2.Empty.FromString,
('Calculator', 'SendEvents'):
Number.FromString,
('Calculator', 'SquareRoot'):
Number.FromString,
}
response_serializers = {
('Calculator', 'Chat'): Number.SerializeToString,
('Calculator', 'ReceiveEvents'): Number.SerializeToString,
('Calculator', 'SendEvents'): Number.SerializeToString,
('Calculator', 'SquareRoot'): Number.SerializeToString,
}
method_implementations = {
('Calculator', 'Chat'):
face_utilities.stream_stream_inline(servicer.Chat),
('Calculator', 'ReceiveEvents'):
face_utilities.unary_stream_inline(servicer.ReceiveEvents),
('Calculator', 'SendEvents'):
face_utilities.stream_unary_inline(servicer.SendEvents),
('Calculator', 'SquareRoot'):
face_utilities.unary_unary_inline(servicer.SquareRoot),
}
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_Bridge_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 = {
('Bridge', 'GetX'): NullMessage.FromString,
('Bridge', 'Init'): NullMessage.FromString,
('Bridge', 'Run'): Item.FromString,
('Bridge', 'SetX'): X.FromString,
('Bridge', 'StoreMetric'): Item.FromString,
}
response_serializers = {
('Bridge', 'GetX'): X.SerializeToString,
('Bridge', 'Init'): NullMessage.SerializeToString,
('Bridge', 'Run'): Item.SerializeToString,
('Bridge', 'SetX'): NullMessage.SerializeToString,
('Bridge', 'StoreMetric'): NullMessage.SerializeToString,
}
method_implementations = {
('Bridge', 'GetX'):
face_utilities.unary_unary_inline(servicer.GetX),
('Bridge', 'Init'):
face_utilities.unary_unary_inline(servicer.Init),
('Bridge', 'Run'):
face_utilities.stream_stream_inline(servicer.Run),
('Bridge', 'SetX'):
face_utilities.unary_unary_inline(servicer.SetX),
('Bridge', 'StoreMetric'):
face_utilities.stream_unary_inline(servicer.StoreMetric),
}
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_EntryDataService_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 = {
('etg.data.entry.EntryDataService', 'GetEntryStatus'):
GetEntryStatusRequest.FromString,
('etg.data.entry.EntryDataService', 'GetYDTEntryDataAt'):
GetYDTEntryDataRequest.FromString,
('etg.data.entry.EntryDataService', 'GetYDTEntryDataFrom'):
GetYDTEntryDataRequest.FromString,
}
response_serializers = {
('etg.data.entry.EntryDataService', 'GetEntryStatus'):
GetEntryStatusResponse.SerializeToString,
('etg.data.entry.EntryDataService', 'GetYDTEntryDataAt'):
GetYDTEntryDataResponse.SerializeToString,
('etg.data.entry.EntryDataService', 'GetYDTEntryDataFrom'):
GetYDTEntryDataResponse.SerializeToString,
}
method_implementations = {
('etg.data.entry.EntryDataService', 'GetEntryStatus'):
face_utilities.stream_stream_inline(servicer.GetEntryStatus),
('etg.data.entry.EntryDataService', 'GetYDTEntryDataAt'):
face_utilities.unary_unary_inline(servicer.GetYDTEntryDataAt),
('etg.data.entry.EntryDataService', 'GetYDTEntryDataFrom'):
face_utilities.unary_stream_inline(servicer.GetYDTEntryDataFrom),
}
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_Peer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
import fabric_pb2
import fabric_pb2
import fabric_pb2
import fabric_pb2
request_deserializers = {
('protos.Peer', 'Chat'): fabric_pb2.Message.FromString,
('protos.Peer', 'ProcessTransaction'): fabric_pb2.Transaction.FromString,
}
response_serializers = {
('protos.Peer', 'Chat'): fabric_pb2.Message.SerializeToString,
('protos.Peer', 'ProcessTransaction'): fabric_pb2.Response.SerializeToString,
}
method_implementations = {
('protos.Peer', 'Chat'): face_utilities.stream_stream_inline(servicer.Chat),
('protos.Peer', 'ProcessTransaction'): face_utilities.unary_unary_inline(servicer.ProcessTransaction),
}
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_Remoting_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 = {
('remote.Remoting', 'Connect'): ConnectRequest.FromString,
('remote.Remoting', 'Receive'): MessageBatch.FromString,
}
response_serializers = {
('remote.Remoting', 'Connect'): ConnectResponse.SerializeToString,
('remote.Remoting', 'Receive'): Unit.SerializeToString,
}
method_implementations = {
('remote.Remoting', 'Connect'): face_utilities.unary_unary_inline(servicer.Connect),
('remote.Remoting', 'Receive'): face_utilities.stream_stream_inline(servicer.Receive),
}
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_PublishBuildEvent_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.devtools.build.v1.PublishBuildEvent', 'PublishBuildToolEventStream'): OrderedBuildEvent.FromString,
('google.devtools.build.v1.PublishBuildEvent', 'PublishLifecycleEvent'): PublishLifecycleEventRequest.FromString,
}
response_serializers = {
('google.devtools.build.v1.PublishBuildEvent', 'PublishBuildToolEventStream'): PublishBuildToolEventStreamResponse.SerializeToString,
('google.devtools.build.v1.PublishBuildEvent', 'PublishLifecycleEvent'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
}
method_implementations = {
('google.devtools.build.v1.PublishBuildEvent', 'PublishBuildToolEventStream'): face_utilities.stream_stream_inline(servicer.PublishBuildToolEventStream),
('google.devtools.build.v1.PublishBuildEvent', 'PublishLifecycleEvent'): face_utilities.unary_unary_inline(servicer.PublishLifecycleEvent),
}
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_Speech_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
import google.cloud.speech.v1.cloud_speech_pb2
import google.cloud.speech.v1.cloud_speech_pb2
import google.cloud.speech.v1.cloud_speech_pb2
import google.cloud.speech.v1.cloud_speech_pb2
request_deserializers = {
('google.cloud.speech.v1.Speech', 'NonStreamingRecognize'):
google.cloud.speech.v1.cloud_speech_pb2.RecognizeRequest.FromString,
('google.cloud.speech.v1.Speech', 'Recognize'):
google.cloud.speech.v1.cloud_speech_pb2.RecognizeRequest.FromString,
}
response_serializers = {
('google.cloud.speech.v1.Speech', 'NonStreamingRecognize'):
google.cloud.speech.v1.cloud_speech_pb2.NonStreamingRecognizeResponse.
SerializeToString,
('google.cloud.speech.v1.Speech', 'Recognize'):
google.cloud.speech.v1.cloud_speech_pb2.RecognizeResponse.
SerializeToString,
}
method_implementations = {
('google.cloud.speech.v1.Speech', 'NonStreamingRecognize'):
face_utilities.unary_unary_inline(servicer.NonStreamingRecognize),
('google.cloud.speech.v1.Speech', 'Recognize'):
face_utilities.stream_stream_inline(servicer.Recognize),
}
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_HealthDiscoveryService_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 = {
('envoy.service.discovery.v2.HealthDiscoveryService', 'FetchHealthCheck'):
HealthCheckRequestOrEndpointHealthResponse.FromString,
('envoy.service.discovery.v2.HealthDiscoveryService', 'StreamHealthCheck'):
HealthCheckRequestOrEndpointHealthResponse.FromString,
}
response_serializers = {
('envoy.service.discovery.v2.HealthDiscoveryService', 'FetchHealthCheck'):
HealthCheckSpecifier.SerializeToString,
('envoy.service.discovery.v2.HealthDiscoveryService', 'StreamHealthCheck'):
HealthCheckSpecifier.SerializeToString,
}
method_implementations = {
('envoy.service.discovery.v2.HealthDiscoveryService', 'FetchHealthCheck'):
face_utilities.unary_unary_inline(servicer.FetchHealthCheck),
('envoy.service.discovery.v2.HealthDiscoveryService', 'StreamHealthCheck'):
face_utilities.stream_stream_inline(servicer.StreamHealthCheck),
}
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_gRIBI_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('gribi.gRIBI', 'Modify'): ModifyRequest.FromString,
}
response_serializers = {
('gribi.gRIBI', 'Modify'): ModifyResponse.SerializeToString,
}
method_implementations = {
('gribi.gRIBI', 'Modify'):
face_utilities.stream_stream_inline(servicer.Modify),
}
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_OCPyNMS_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
import pynms_rpc_pb2
import pynms_rpc_pb2
import pynms_rpc_pb2
import pynms_rpc_pb2
import pynms_rpc_pb2
import pynms_rpc_pb2
request_deserializers = {
('pynms_api.OCPyNMS', 'Get'): pynms_rpc_pb2.GetRequest.FromString,
('pynms_api.OCPyNMS', 'Set'): pynms_rpc_pb2.SetRequest.FromString,
('pynms_api.OCPyNMS', 'Subscribe'): pynms_rpc_pb2.SubscribeRequest.FromString,
}
response_serializers = {
('pynms_api.OCPyNMS', 'Get'): pynms_rpc_pb2.GetResponse.SerializeToString,
('pynms_api.OCPyNMS', 'Set'): pynms_rpc_pb2.SetResponse.SerializeToString,
('pynms_api.OCPyNMS', 'Subscribe'): pynms_rpc_pb2.SubscribeResponse.SerializeToString,
}
method_implementations = {
('pynms_api.OCPyNMS', 'Get'): face_utilities.unary_unary_inline(servicer.Get),
('pynms_api.OCPyNMS', 'Set'): face_utilities.unary_unary_inline(servicer.Set),
('pynms_api.OCPyNMS', 'Subscribe'): face_utilities.stream_stream_inline(servicer.Subscribe),
}
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_Greeter_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('Greeter', 'SayHello'): HelloRequest.FromString,
('Greeter', 'SayHelloGoodbye'): HelloRequest.FromString,
('Greeter', 'SayHelloToMany'): HelloRequest.FromString,
('Greeter', 'SayHelloToManyAtOnce'): HelloRequest.FromString,
}
response_serializers = {
('Greeter', 'SayHello'): HelloReply.SerializeToString,
('Greeter', 'SayHelloGoodbye'): HelloReply.SerializeToString,
('Greeter', 'SayHelloToMany'): HelloReply.SerializeToString,
('Greeter', 'SayHelloToManyAtOnce'): HelloReply.SerializeToString,
}
method_implementations = {
('Greeter', 'SayHello'):
face_utilities.unary_unary_inline(servicer.SayHello),
('Greeter', 'SayHelloGoodbye'):
face_utilities.unary_stream_inline(servicer.SayHelloGoodbye),
('Greeter', 'SayHelloToMany'):
face_utilities.stream_stream_inline(servicer.SayHelloToMany),
('Greeter', 'SayHelloToManyAtOnce'):
face_utilities.stream_unary_inline(servicer.SayHelloToManyAtOnce),
}
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)
