async def main(): channel = Channel('127.0.0.1', 50051) stub = ChallengeStub(channel) challenge = await stub.create(name='Mr. Easy') print(challenge.id, challenge.name) async for challenge in stub.list(): print(challenge.id, challenge.name) channel.close()
async def main(rmq_host, rmq_port, rollout_size, max_dota_time, latest_weights_prob, initial_model, validation, log_dir): logger.info('main(rmq_host={}, rmq_port={})'.format(rmq_host, rmq_port)) # RMQ rmq_connection = pika.BlockingConnection( pika.ConnectionParameters(host=rmq_host, port=rmq_port, heartbeat=300)) experience_channel = rmq_connection.channel() experience_channel.queue_declare(queue=EXPERIENCE_QUEUE_NAME) weight_store.ready = asyncio.Event(loop=asyncio.get_event_loop()) global writer writer = SummaryWriter(log_dir=log_dir) # Optionally if initial_model: weight_store.load_from_gcs(initial_model) # Set up the model callback. await setup_model_cb(host=rmq_host, port=rmq_port) # Wait for the first model weight to come in. await weight_store.ready.wait() # Connect to dota channel_dota = Channel(DOTASERVICE_HOST, DOTASERVICE_PORT, loop=asyncio.get_event_loop()) dota_service = DotaServiceStub(channel_dota) game = Game(dota_service=dota_service, experience_channel=experience_channel, rollout_size=rollout_size, max_dota_time=max_dota_time, latest_weights_prob=latest_weights_prob, validation=validation) for i in range(0, N_GAMES): logger.info('=== Starting Game {}.'.format(i)) game_id = str(datetime.now().strftime('%b%d_%H-%M-%S')) if validation: config = get_1v1_bot_vs_default_config(validation_team=validation) else: config = get_1v1_selfplay_config() try: await game.play(config=config, game_id=game_id) except: traceback.print_exc() return channel_dota.close()
async def build( cls, host: str, port: int, is_local: bool, logger: logging.Logger) -> AsyncContextManager[IdbClientBase]: channel = Channel(host=host, port=port, loop=asyncio.get_event_loop()) try: yield IdbClient( stub=CompanionServiceStub(channel=channel), is_local=is_local, logger=logger, ) finally: channel.close()
async def run(parser: ArgumentParser, args: Namespace, command_cls: Type[ClientCommand]) -> int: loop = asyncio.get_event_loop() path = args.socket or AdminService.get_socket_path() channel = Channel(path=path, loop=loop) stub = AdminStub(channel) command = command_cls(stub, args) try: code = await command.run(args.outfile) finally: channel.close() return code
async def main(*, host: str = 'localhost', port: int = 50051) -> None: channel = Channel(host, port, ssl=create_secure_context( CLIENT_CERT, CLIENT_KEY, trusted=SERVER_CERT, )) stub = HealthStub(channel) response = await stub.Check(HealthCheckRequest()) print(response) channel.close()
class Protoconf(object): def __init__(self, host="127.0.0.1", port=AGENT_DEFAULT_PORT): self._host = host self._port = port self._clear_state() def _clear_state(self): self._channel = None self._streams = [] self._updates_tasks = [] async def get_and_subscribe(self, path, protobuf_type, callback): if self._channel == None: self._channel = Channel(self._host, self._port) stream = (await ProtoconfServiceStub( self._channel).SubscribeForConfig.open().__aenter__()) await stream.send_message(ConfigSubscriptionRequest(path=path)) async def get_config(): protoconf_value = await stream.recv_message() if protoconf_value == None: return None config = protobuf_type() protoconf_value.value.Unpack(config) return config config = await get_config() if config != None and callback != None: self._streams.append(stream) async def get_updates(): while True: config = await get_config() if config == None: break asyncio.ensure_future(callback(config)) self._updates_tasks.append(asyncio.ensure_future(get_updates())) else: await stream.cancel() return config async def close(self): for stream in self._streams: await stream.cancel() await stream.__aexit__(None, None, None) for task in self._updates_tasks: task.cancel() self._channel.close() self._clear_state()
async def call(self, operation, address, vnfbr): vnfbr_pb = vnfbr.protobuf() layout = Layout(feat=operation) layout.vnfbr.CopyFrom(vnfbr_pb) ip, port = address.split(":") channel = Channel(ip, port) stub = PlayerStub(channel) reply, error = await self.call_stub(stub.CallLayout, layout) channel.close() return reply, error
async def main() -> None: channel = Channel('127.0.0.1', 50051) primes = PrimesStub(channel) async def check(n: int) -> Tuple[int, bool]: reply = await primes.Check(Request(number=n)) return n, reply.is_prime.value for f in asyncio.as_completed([check(n) for n in PRIMES]): number, is_prime = await f print(f'Number {number} {"is" if is_prime else "is not"} prime') channel.close()
async def call_task(self, uuid, task): """Calls a task in a Manager component using a gRPC stub Arguments: uuid {string} -- The uuid of a Manager component that is a peer of Player and by whom the Task will be executed task {Task} -- A gRPC message of type Task that the Manager component being called will have to execute Returns: dict -- All the information of a Report message obtained from a Manager component after running the called Task message """ logger.info(f"Calling test task at manager uuid {uuid}") logger.debug(f"{json_format.MessageToJson(task)}") peers = self.status.get_peers("role", "manager") peer = peers.get(uuid) address = peer.get("address") host, port = address.split(":") channel = Channel(host, port) report_msg = Report(id=task.id, test=task.test) try: stub = ManagerStub(channel) report_msg = await stub.CallTask(task) except GRPCError as e: logger.info(f"Error in task call") logger.debug(f"{repr(e)}") report_msg = Report(id=task.id, test=task.test, error=repr(e)) except OSError as e: logger.info(f"Error in channel for task call") logger.debug(f"{repr(e)}") report_msg = Report(id=task.id, test=task.test, error=repr(e)) else: logger.debug(f"Report received") finally: logger.debug(f"{json_format.MessageToJson(report_msg)}") report = json_format.MessageToDict(report_msg) channel.close() return report
async def main(): # Create a gRPC channel + await daq_service. channel = Channel(host=server_address, port=server_port) daq_service = nidaqmx_grpc.NiDAQmxStub(channel) task = None # Raise an exception if an error was returned async def raise_if_error(response): if response.status != 0: response = await daq_service.get_error_string( error_code=response.status) raise Exception(f"Error: {response.error_string}") try: response = await daq_service.create_task() await raise_if_error(response) task = response.task await raise_if_error(await daq_service.create_d_i_chan( task=task, lines=lines, line_grouping_raw=nidaqmx_grpc.LineGrouping. LINE_GROUPING_CHAN_FOR_ALL_LINES, )) await raise_if_error(await daq_service.start_task(task=task)) response = await daq_service.read_digital_u32( task=task, num_samps_per_chan=1, array_size_in_samps=1, fill_mode_raw=nidaqmx_grpc.GroupBy.GROUP_BY_GROUP_BY_CHANNEL, timeout=10.0, ) await raise_if_error(response) print(f"Data acquired: {hex(response.read_array[0])}") except GRPCError as e: if e.status.name == "UNIMPLEMENTED": print( "The operation is not implemented or is not supported/enabled in this service" ) else: print(f"GRPCError: {str(e)}") except Exception as e: print(str(e)) finally: if task: await daq_service.stop_task(task=task) await daq_service.clear_task(task=task) channel.close()
async def benchmark(loop, seconds=DEFAULT_SECONDS, concurrency=DEFAULT_CONCURRENCY): global finish_benchmark print("Creating stubs and warmming up ....") stubs = [] channels = [] for i in range(concurrency): channel = Channel('127.0.0.1', 50051, loop=loop) echo_stub = echo_grpc.EchoStub(channel) echo_reply = await echo_stub.Hi(echo_pb2.EchoRequest(message="ping")) assert echo_reply.message stubs.append(echo_stub) channels.append(channel) print("Starting tasks ....") tasks = [ asyncio.ensure_future(requests(idx, echo_stub)) for idx, echo_stub in enumerate(stubs) ] await asyncio.sleep(seconds) print("Finishing tasks ....") finish_benchmark = True while not all([task.done() for task in tasks]): await asyncio.sleep(0) for channel in channels: channel.close() times = [] for task in tasks: times += task.result() times.sort() total_requests = len(times) avg = sum(times) / total_requests p75 = times[int((75 * total_requests) / 100)] p90 = times[int((90 * total_requests) / 100)] p99 = times[int((99 * total_requests) / 100)] print('QPS: {0}'.format(int(total_requests / seconds))) print('Avg: {0:.6f}'.format(avg)) print('P75: {0:.6f}'.format(p75)) print('P90: {0:.6f}'.format(p90)) print('P99: {0:.6f}'.format(p99))
async def run_instruction(self): uuid, address = "agent-test", "127.0.0.1:50051" p = self.start_agent(uuid, address) await asyncio.sleep(1.0) channel = Channel("127.0.0.1", 50051) stub = gym_grpc.AgentStub(channel) instruction_reply = await self.call_instruction(stub) channel.close() ack = self.stop_agent(p) assert ack == True return instruction_reply
async def main(): channel = Channel(loop=asyncio.get_event_loop(), host=settings.GRPC_SERVER_HOST, port=settings.GRPC_SERVER_PORT) stub = BillingServiceStub(channel) reply = await stub.Register( RegisterRequest(name='jackdoe', country='Russia', city='Kursk', currency='EUR')) print("REPLY HERE", reply, type(reply)) channel.close()
async def run(): channel = Channel(host='padplus.juzibot.com', port=50051) puppet_stub = PadPlusServerStub(channel) async for response in puppet_stub.init(token=token): # 一直卡在这里,没有收到消息 # 所以怎么来获取事件,登录呢?这里有点疑惑 print(response) # 这里应该是需要有一定的信息从init响应中返回 response = await puppet_stub.request( RequestObject(token=token, api_type=ApiType.INIT)) print(response) channel.close()
def channel_fixture(loop, port): services = [DummyService()] services = ServerReflection.extend(services) server = Server(services, loop=loop) loop.run_until_complete(server.start(port=port)) channel = Channel(port=port, loop=loop) try: yield channel finally: channel.close() server.close() loop.run_until_complete(server.wait_closed())
async def _companion_to_target( self, companion: CompanionInfo) -> Optional[TargetDescription]: try: channel = Channel(companion.host, companion.port, loop=asyncio.get_event_loop()) stub = CompanionServiceStub(channel=channel) response = await stub.describe(TargetDescriptionRequest()) channel.close() return target_to_py(response.target_description) except Exception: self.logger.warning(f"Failed to describe {companion}, removing it") self.direct_companion_manager.remove_companion( Address(companion.host, companion.port)) return None
async def main(): """doc""" channel = Channel(host="127.0.0.1", port=8788) puppet = PuppetStub(channel) event_stream = AsyncIOEventEmitter() event_stream.on('EVENT_TYPE_DONG', \ lambda payload: print('on(dong) %s' % payload)) await asyncio.gather( loop(lambda: puppet.ding(data='haha')), init_event_stream(event_stream, puppet), ) channel.close()
async def run_info(self): uuid, address = "monitor-test", "127.0.0.1:50051" p = self.start_monitor(uuid, address) await asyncio.sleep(1.0) channel = Channel("127.0.0.1", 50051) stub = gym_grpc.MonitorStub(channel) info_reply = await self.call_info(stub) channel.close() ack = self.stop_monitor(p) assert ack == True return info_reply
async def speech_stream_to_text(speech_stream): channel = Channel('stt.api.cloud.yandex.net', 443, ssl=True) try: stub = SttServiceStub(channel) sent = asyncio.Event() async with stub.StreamingRecognize.open( metadata=[('authorization', get_authorization_header())]) as stream: async with background_task( write_to_stream(stream, speech_stream, sent)): await sent.wait() async for text in read_from_stream(stream): yield text finally: channel.close()
async def main(*, host: str, port: int): chan = Channel(host=host, port=port) player = PlayerServiceStub(chan) async for res in player.open( screen_path=screen_path, video_path=video_path, vstream_idx=0, frame_wait=frame_wait, start=start, step=step, ): print(res.action, res.ok, res.err, res.frame_count) chan.close() print("closed")
async def build( cls, companion_info: CompanionInfo, logger: logging.Logger) -> AsyncContextManager["GrpcStubClient"]: channel = Channel( host=companion_info.host, port=companion_info.port, loop=asyncio.get_event_loop(), ) try: yield GrpcStubClient( stub=CompanionServiceStub(channel=channel), companion_info=companion_info, logger=logger, ) finally: channel.close()
async def run_info(self): roles = ["agent", "monitor", "manager"] ps = self.start_components(roles) await asyncio.sleep(2.0) channel = Channel("127.0.0.1", 50053) stub = gym_grpc.ManagerStub(channel) info_reply = await self.call_info(stub) channel.close() ack = self.stop_components(ps) assert ack == True return info_reply
async def call_peer(self, role, address, instruction): """Performs the call of a instruction in a agent/monitor peer. Arguments: role {string} -- The role of the peer being called (i.e., agent or monitor) address {string} -- The address (ip:port) of the peer being called instruction {Instruction} -- A gRPC message of type Instruction Returns: Snapshot -- A gRPC message of type Snapshot if not exceptions are raised because of grpc error or os error """ reply = Snapshot(id=instruction.id) host, port = address.split(":") channel = Channel(host, port) if role == "agent": stub = AgentStub(channel) elif role == "monitor": stub = MonitorStub(channel) else: stub = None logger.info( f"Could not contact role {role} - no stub/client available") raise (Exception(f"No stub/client available for {role}")) try: reply = await stub.CallInstruction(instruction) except GRPCError as e: logger.info(f"Error in instruction call at {address}") logger.debug(f"Exception: {repr(e)}") raise (e) except OSError as e: logger.info( f"Could not open channel for instruction call at {address}") logger.debug(f"Exception: {repr(e)}") raise (e) channel.close() return reply
class Client: def __init__(self, host='127.0.0.1', port=2379, *, ttl=10): self._channel = Channel(host, port) self._kvstub = _etcd.KVStub(self._channel) self._leasestub = _etcd.LeaseStub(self._channel) self._watchstub = _etcd.WatchStub(self._channel) from .lease import Lease self._session = Lease(ttl, client=self) def __del__(self): self._channel.close() async def start_session(self): await self._session.grant() @property def session_id(self): return self._session.id def Delete(self, *args, **kwargs): return request.Delete(*args, **kwargs, client=self) def DeleteRange(self, *args, **kwargs): return request.DeleteRange(*args, **kwargs, client=self) def Get(self, *args, **kwargs): return request.Get(*args, **kwargs, client=self) def LeaseGrant(self, *args, **kwargs): return request.LeaseGrant(*args, **kwargs, client=self) def LeaseKeepAlive(self, *args, **kwargs): return request.LeaseKeepAlive(*args, **kwargs, client=self) def LeaseRevoke(self, *args, **kwargs): return request.LeaseRevoke(*args, **kwargs, client=self) def Put(self, *args, **kwargs): return request.Put(*args, **kwargs, client=self) def Range(self, *args, **kwargs): return request.Range(*args, **kwargs, client=self) def Txn(self, *args, **kwargs): return request.Txn(*args, **kwargs, client=self)
async def test_channel_transient_failure(loop): channel = Channel() async def _create_connection(): await asyncio.sleep(0.01) raise asyncio.TimeoutError('try again later') with patch.object(channel, '_create_connection', _create_connection): assert channel._state is _ChannelState.IDLE connect_task = loop.create_task(channel.__connect__()) await asyncio.sleep(0.001) assert channel._state is _ChannelState.CONNECTING with pytest.raises(asyncio.TimeoutError, match='try again later'): await connect_task assert channel._state is _ChannelState.TRANSIENT_FAILURE channel.close() assert channel._state is _ChannelState.IDLE
async def test_channel_ready(loop): async with ChannelFor([WorkingDummyService()]) as _channel: channel = Channel() async def _create_connection(): await asyncio.sleep(0.01) return _channel._protocol with patch.object(channel, '_create_connection', _create_connection): assert channel._state is _ChannelState.IDLE connect_task = loop.create_task(channel.__connect__()) await asyncio.sleep(0.001) assert channel._state is _ChannelState.CONNECTING await connect_task assert channel._state is _ChannelState.READY channel.close() assert channel._state is _ChannelState.IDLE
class Connection: ''' An active connection to a model serving GRPC server ''' TIMEOUT_SECONDS = 5 def __init__( self, addr: str, port: int, pem: str = None, channel_options: dict = None, loop: asyncio.AbstractEventLoop = None, ): self.addr = addr self.port = port if channel_options is None: channel_options = {} if pem is None: make_sync_channel = partial(grpc.insecure_channel, options=channel_options) else: creds = grpc.ssl_channel_credentials(pem) make_sync_channel = partial( grpc.secure_channel, credentials=creds, options=channel_options, ) if loop is None: loop = asyncio.get_event_loop() self.sync_channel = make_sync_channel(f"{addr}:{port}") self.async_channel = Channel(addr, port, loop=loop) self.sync_stub = prediction_service_pb2_grpc.PredictionServiceStub(self.sync_channel) self.async_stub = prediction_service_grpc.PredictionServiceStub(self.async_channel) def __del__(self): self.async_channel.close() del self.async_channel
class Client: def __init__(self, loop): self.channel = Channel("127.0.0.1", 5000, loop=loop) self.stub = ssStub(self.channel) async def get_user(self, user_id: int): user = await self.stub.GetUser(UserIdReq(user_id=1)) print(f"user: {user}") async def list_user(self, tcp_conn_num): res = await self.stub.ListUser(UserReq(tcp_conn_num=tcp_conn_num)) print(f"list_user: {res}") async def healcheck(self, url: str): res = await self.stub.HealthCheck(HealthCheckReq(url=url)) print(f"health: {res}") def close(self): self.channel.close()
async def call_monitor_event(self, scenario): monitor_events = scenario.get("eventsv2").get("monitor") # extract all the actions from monitor_events to # construct the Instruction message monitor_actions = [] for ev in monitor_events: for action in ev.get("actions"): monitor_actions.append(action) instr_dict = {"id": scenario.get("id"), "actions": monitor_actions} ip, port = self.scenario.entrypoint.get("umbra-monitor").split(':') channel = Channel(ip, int(port)) stub = MonitorStub(channel) instruction = json_format.ParseDict(instr_dict, Instruction()) reply = await stub.Listen(instruction) channel.close()
async def run(parser: ArgumentParser, args: Namespace, command_cls: type[Command]) -> int: config = Config(args) ssl = create_default_context(cafile=config.cafile, capath=config.capath) if config.no_verify_cert: ssl.check_hostname = False ssl.verify_mode = CERT_NONE if config.host is not None or config.port is not None: channel = Channel(host=config.host, port=config.port, ssl=ssl) else: path = socket_file.find() if path is None: parser.error('Running server not found, please provide ' '--host, --port, or --path.') channel = Channel(path=str(path)) command = command_cls(args, channel) try: return await command(sys.stdout) finally: channel.close()