def __init__(self, channel, rpc_mode='REQUEST_REPLY', thread_pool_executor=None): """Creates a remote executor. Args: channel: An instance of `grpc.Channel` to use for communication with the remote executor service. rpc_mode: Optional mode of calling the remote executor. Must be either 'REQUEST_REPLY' or 'STREAMING' (defaults to 'REQUEST_REPLY'). This option will be removed after the request-reply interface is deprecated. thread_pool_executor: Optional concurrent.futures.Executor used to wait for the reply to a streaming RPC message. Uses the default Executor if not specified. """ py_typecheck.check_type(channel, grpc.Channel) py_typecheck.check_type(rpc_mode, str) if rpc_mode not in ['REQUEST_REPLY', 'STREAMING']: raise ValueError('Invalid rpc_mode: {}'.format(rpc_mode)) self._stub = executor_pb2_grpc.ExecutorStub(channel) self._bidi_stream = None if rpc_mode == 'STREAMING': self._bidi_stream = _BidiStream(self._stub, thread_pool_executor)
def __init__(self, channel): """Creates a remote executor. Args: channel: An instance of `grpc.Channel` to use for communication with the remote executor service. """ py_typecheck.check_type(channel, grpc.Channel) self._stub = executor_pb2_grpc.ExecutorStub(channel)
def __init__(self, executor): port = portpicker.pick_unused_port() server_pool = logging_pool.pool(max_workers=1) self._server = grpc.server(server_pool) self._server.add_insecure_port('[::]:{}'.format(port)) self._service = executor_service.ExecutorService(executor) executor_pb2_grpc.add_ExecutorServicer_to_server( self._service, self._server) self._server.start() self._channel = grpc.insecure_channel('localhost:{}'.format(port)) self._stub = executor_pb2_grpc.ExecutorStub(self._channel)
def setUp(self): super(ExecutorServiceTest, self).setUp() port = portpicker.pick_unused_port() server_pool = logging_pool.pool(max_workers=1) self._server = grpc.server(server_pool) self._server.add_insecure_port('[::]:{}'.format(port)) self._service = executor_service.ExecutorService( eager_executor.EagerExecutor()) executor_pb2_grpc.add_ExecutorServicer_to_server( self._service, self._server) self._server.start() self._channel = grpc.insecure_channel('localhost:{}'.format(port)) self._stub = executor_pb2_grpc.ExecutorStub(self._channel)
def __init__(self, channel, rpc_mode='REQUEST_REPLY', thread_pool_executor=None, dispose_batch_size=20): """Creates a remote executor. Args: channel: An instance of `grpc.Channel` to use for communication with the remote executor service. rpc_mode: Optional mode of calling the remote executor. Must be either 'REQUEST_REPLY' or 'STREAMING' (defaults to 'REQUEST_REPLY'). This option will be removed after the request-reply interface is deprecated. thread_pool_executor: Optional concurrent.futures.Executor used to wait for the reply to a streaming RPC message. Uses the default Executor if not specified. dispose_batch_size: The batch size for requests to dispose of remote worker values. Lower values will result in more requests to the remote worker, but will result in values being cleaned up sooner and therefore may result in lower memory usage on the remote worker. """ py_typecheck.check_type(channel, grpc.Channel) py_typecheck.check_type(rpc_mode, str) py_typecheck.check_type(dispose_batch_size, int) if rpc_mode not in ['REQUEST_REPLY', 'STREAMING']: raise ValueError('Invalid rpc_mode: {}'.format(rpc_mode)) logging.debug('Creating new ExecutorStub with RPC_MODE=%s', rpc_mode) self._channel_status = False def _channel_status_callback( channel_connectivity: grpc.ChannelConnectivity): self._channel_status = channel_connectivity channel.subscribe(_channel_status_callback, try_to_connect=True) # We need to keep a reference to the channel around to prevent the Python # object from being GC'ed and the callback above from no-op'ing. self._channel = channel self._stub = executor_pb2_grpc.ExecutorStub(channel) self._bidi_stream = None self._dispose_batch_size = dispose_batch_size self._dispose_request = executor_pb2.DisposeRequest() if rpc_mode == 'STREAMING': logging.debug('Creating Bidi stream') self._bidi_stream = _BidiStream(self._stub, thread_pool_executor)
def __init__(self, channel, rpc_mode=None, thread_pool_executor=None, dispose_batch_size=20): """Creates a remote executor. Args: channel: An instance of `grpc.Channel` to use for communication with the remote executor service. rpc_mode: (Deprecated) string, one of 'REQUEST_REPLY' or 'STREAMING'. Unused, still here for backwards compatibility. thread_pool_executor: Optional concurrent.futures.Executor used to wait for the reply to a streaming RPC message. Uses the default Executor if not specified. dispose_batch_size: The batch size for requests to dispose of remote worker values. Lower values will result in more requests to the remote worker, but will result in values being cleaned up sooner and therefore may result in lower memory usage on the remote worker. """ py_typecheck.check_type(channel, grpc.Channel) py_typecheck.check_type(dispose_batch_size, int) if rpc_mode is not None: warnings.warn( 'The rpc_mode argument is deprecated and slated for ' 'removal. Please update your callsites to avoid specifying ' 'rpc_mode.') del rpc_mode logging.debug('Creating new ExecutorStub') self._channel_status = False def _channel_status_callback( channel_connectivity: grpc.ChannelConnectivity): self._channel_status = channel_connectivity channel.subscribe(_channel_status_callback, try_to_connect=True) # We need to keep a reference to the channel around to prevent the Python # object from being GC'ed and the callback above from no-op'ing. self._channel = channel self._stub = executor_pb2_grpc.ExecutorStub(channel) self._dispose_batch_size = dispose_batch_size self._dispose_request = executor_pb2.DisposeRequest()
def __init__(self, ex_factory: executor_factory.ExecutorFactory, num_clients: int = 0): port = portpicker.pick_unused_port() self._server_pool = logging_pool.pool(max_workers=1) self._server = grpc.server(self._server_pool) self._server.add_insecure_port('[::]:{}'.format(port)) self._service = executor_service.ExecutorService(ex_factory=ex_factory) executor_pb2_grpc.add_ExecutorServicer_to_server(self._service, self._server) self._server.start() self._channel = grpc.insecure_channel('localhost:{}'.format(port)) self._stub = executor_pb2_grpc.ExecutorStub(self._channel) serialized_cards = executor_serialization.serialize_cardinalities( {placement_literals.CLIENTS: num_clients}) self._stub.SetCardinalities( executor_pb2.SetCardinalitiesRequest(cardinalities=serialized_cards))
def test_context(rpc_mode='REQUEST_REPLY'): port = portpicker.pick_unused_port() server_pool = logging_pool.pool(max_workers=1) server = grpc.server(server_pool) server.add_insecure_port('[::]:{}'.format(port)) target_factory = executor_stacks.local_executor_factory(num_clients=3) tracers = [] def _tracer_fn(cardinalities): tracer = executor_test_utils.TracingExecutor( target_factory.create_executor(cardinalities)) tracers.append(tracer) return tracer service = executor_service.ExecutorService( executor_stacks.ResourceManagingExecutorFactory(_tracer_fn)) executor_pb2_grpc.add_ExecutorServicer_to_server(service, server) server.start() channel = grpc.insecure_channel('localhost:{}'.format(port)) stub = executor_pb2_grpc.ExecutorStub(channel) serialized_cards = executor_service_utils.serialize_cardinalities( {placement_literals.CLIENTS: 3}) stub.SetCardinalities( executor_pb2.SetCardinalitiesRequest(cardinalities=serialized_cards)) remote_exec = remote_executor.RemoteExecutor(channel, rpc_mode) executor = reference_resolving_executor.ReferenceResolvingExecutor( remote_exec) try: yield collections.namedtuple('_', 'executor tracers')(executor, tracers) finally: executor.close() for tracer in tracers: tracer.close() try: channel.close() except AttributeError: pass # Public gRPC channel doesn't support close() finally: server.stop(None)
def __init__(self, channel, thread_pool_executor=None, dispose_batch_size=20): """Creates a remote executor. Args: channel: An instance of `grpc.Channel` to use for communication with the remote executor service. thread_pool_executor: Optional concurrent.futures.Executor used to wait for the reply to a streaming RPC message. Uses the default Executor if not specified. dispose_batch_size: The batch size for requests to dispose of remote worker values. Lower values will result in more requests to the remote worker, but will result in values being cleaned up sooner and therefore may result in lower memory usage on the remote worker. """ py_typecheck.check_type(channel, grpc.Channel) py_typecheck.check_type(dispose_batch_size, int) logging.debug('Creating new ExecutorStub') self._channel_status = False def _channel_status_callback( channel_connectivity: grpc.ChannelConnectivity): self._channel_status = channel_connectivity channel.subscribe(_channel_status_callback, try_to_connect=True) # We need to keep a reference to the channel around to prevent the Python # object from being GC'ed and the callback above from no-op'ing. self._channel = channel self._stub = executor_pb2_grpc.ExecutorStub(channel) self._dispose_batch_size = dispose_batch_size self._dispose_request = executor_pb2.DisposeRequest()