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 callScenario(command, test, vnfbd): deploy_dict = { "id": test, "workflow": command, "scenario": vnfbd.scenario(), } deploy = json_format.ParseDict(deploy_dict, gym_pb2.Deploy()) environment = vnfbd.environment() env_plugin = environment.get("plugin") env_params = env_plugin.get("parameters") address = env_params.get("address").get("value") host, port = address.split(":") channel = Channel(host, port) stub = gym_grpc.InfraStub(channel) built = await stub.Run(deploy) if built.error: ack = False print(f'Scenario not deployed error: {built.error}') else: ack = True print(f'Scenario deployed: {built.ack}') channel.close() return ack
async def connect_to_agent(): actions = [{ 'id': "1", "tool": "ping", "output": { "live": False, "address": None, }, 'parameters': { "target": "peer0.org1.example.com", "interval": "1", "duration": "3", }, 'schedule': { "from": 0, "until": 14, "duration": 0, "interval": 2, "repeat": 1 }, }] inst_dict = { "id": "100", "actions": actions, } channel = Channel("192.168.0.13", 8910) stub = AgentStub(channel) instruction = json_format.ParseDict(inst_dict, Instruction()) reply = await stub.Probe(instruction) print("DONE connect_to_agent reply =", reply) channel.close()
async def call_monitor(self, address, data): logger.info(f"Calling Monitor - {address}") directrix = json_format.ParseDict(data, Directrix()) host, port = address.split(":") try: channel = Channel(host, port) stub = MonitorStub(channel) status = await stub.Measure(directrix) except Exception as e: ack = False info = repr(e) logger.info(f"Error - monitor failed - {info}") else: if status.error: ack = False logger.info(f"Monitor error: {status.error}") info = status.error else: ack = True if status.info: info = self.parse_bytes(status.info) else: info = {} logger.info(f"Monitor info: {info}") finally: channel.close() return ack, info
class ProtoconfMutation(object): def __init__(self, host="127.0.0.1", port=SERVER_DEFAULT_PORT): self._host = host self._port = port self._clear_state() def _clear_state(self): self._channel = None async def mutate_config(self, path, value, script_metadata): if self._channel == None: self._channel = Channel(self._host, self._port) protoconf_service = ProtoconfMutationServiceStub(self._channel) config = ProtoconfValue() config.proto_file = value.DESCRIPTOR.file.name config.value.Pack(value) await protoconf_service.MutateConfig( ConfigMutationRequest(path=path, value=config, script_metadata=script_metadata)) def close(self): self._channel.close() self._clear_state()
async def _send(self, address, message): logger.info(f"Sending message Stats") try: host, port = address.split(":") channel = Channel(host, port) stub = BrokerStub(channel) info = json_format.ParseDict(message, Stats()) reply = await stub.Collect(info) info_reply = json_format.MessageToDict( reply, preserving_proto_field_name=True ) except GRPCError as e: logger.info(f"Error in reaching: Stats") logger.debug(f"Exception in stats: {repr(e)}") info_reply = {} except OSError as e: logger.info(f"Could not reach channel for Stats") logger.debug(f"Exception: {repr(e)}") info_reply = {} except Exception as e: logger.debug(f"Exception: {repr(e)}") info_reply = {} finally: channel.close() logger.info(f"Reply message Stats {info_reply}")
def __init__(self): self._host = os.environ.get("LND_HOST") self._port = int(os.environ.get("LND_PORT")) self._network = os.environ.get("NETWORK") self.id_pubkey = None self.stub = None os.environ["GRPC_SSL_CIPHER_SUITES"] = "HIGH+ECDSA" os.environ["SSL_CERT_DIR"] = "/root/.lnd" with open( f"/root/.lnd/data/chain/bitcoin/{self._network}/admin.macaroon", "rb") as macaroon_bytes: self._macaroon = macaroon_bytes.read().hex() ctx = ssl.SSLContext(ssl.PROTOCOL_TLS) ctx.verify_mode = ssl.CERT_REQUIRED ctx.load_verify_locations(cafile="/root/.lnd/tls.cert") # can take second arg path the private key str(client_key) ctx.load_cert_chain("/root/.lnd/tls.cert", "/root/.lnd/tls.key") # ctx.load_verify_locations(str(trusted)) WE TRUST THE CERTIFICATE ctx.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1 ctx.set_ciphers("ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20") ctx.set_alpn_protocols(["h2"]) try: ctx.set_npn_protocols(["h2"]) except NotImplementedError: pass self._channel = Channel(self._host, self._port, ssl=ctx) async def attach_metadata(event: SendRequest): event.metadata["macaroon"] = self._macaroon listen(self._channel, SendRequest, attach_metadata)
async def run_directrix(self): uuid, address = "monitor-test", "127.0.0.1:50051" monitor_p = self.start_monitor(uuid, address) uuid, address = "broker-test", "127.0.0.1:50052" broker_p = self.start_broker(uuid, address) try: await asyncio.sleep(1.0) channel = Channel("127.0.0.1", 50051) stub = MonitorStub(channel) action = "start" info_reply = await self.call_directrix(stub, action) await asyncio.sleep(10) action = "stop" info_reply = await self.call_directrix(stub, action) except Exception as e: logger.info(f"run directrix exception - {repr(e)}") info_reply = None finally: channel.close() ack = self.stop_monitor(monitor_p) assert ack == True ack = self.stop_broker(broker_p) assert ack == True return info_reply
class UnixClientServer: temp = None sock = None server = None channel = None async def __aenter__(self): self.temp = tempfile.mkdtemp() self.sock = os.path.join(self.temp, 'grpclib.sock') dummy_service = DummyService() self.server = Server([dummy_service]) await self.server.start(path=self.sock) self.channel = Channel(path=self.sock) dummy_stub = DummyServiceStub(self.channel) return dummy_service, dummy_stub async def __aexit__(self, *exc_info): self.server.close() await self.server.wait_closed() self.channel.close() if os.path.exists(self.sock): os.unlink(self.sock) if os.path.exists(self.temp): os.rmdir(self.temp)
async def get_stub(self) -> AsyncContextManager[CompanionServiceStub]: await self.spawn_notifier() channel: Optional[Channel] = None try: try: self.companion_info = self.direct_companion_manager.get_companion_info( target_udid=self.target_udid ) except IdbException as e: # will try to spawn a companion if on mac. companion_info = await self.spawn_companion( target_udid=none_throws(self.target_udid) ) if companion_info: self.companion_info = companion_info else: raise e self.logger.info(f"using companion {self.companion_info}") channel = Channel( # pyre-fixme[16]: `Optional` has no attribute `host`. self.companion_info.host, # pyre-fixme[16]: `Optional` has no attribute `port`. self.companion_info.port, loop=asyncio.get_event_loop(), ) yield CompanionServiceStub(channel=channel) finally: if channel: channel.close()
async def get_stub(self) -> CompanionServiceStub: channel: Optional[Channel] = None try: try: self.companion_info = self.direct_companion_manager.get_companion_info( target_udid=self.target_udid ) except IdbException as e: # will try to spawn a companion if on mac. if platform.system() == "Darwin" and self.target_udid: self.logger.info( f"will attempt to spawn a companion for {self.target_udid}" ) port = await self.companion_spawner.spawn_companion( target_udid=self.target_udid ) host = "localhost" self.companion_info = CompanionInfo( host=host, port=port, udid=self.target_udid, is_local=True ) self.direct_companion_manager.add_companion(self.companion_info) else: raise e self.logger.info(f"using companion {self.companion_info}") channel = Channel( self.companion_info.host, self.companion_info.port, loop=asyncio.get_event_loop(), ) yield CompanionServiceStub(channel=channel) finally: if channel: channel.close()
class ClientServer: server = None channel = None def __init__(self, *, loop): self.loop = loop async def __aenter__(self): host = '127.0.0.1' with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('127.0.0.1', 0)) _, port = s.getsockname() dummy_service = DummyService() self.server = Server([dummy_service], loop=self.loop) await self.server.start(host, port) self.channel = Channel(host=host, port=port, loop=self.loop) dummy_stub = DummyServiceStub(self.channel) return dummy_service, dummy_stub async def __aexit__(self, *exc_info): self.server.close() await self.server.wait_closed() self.channel.close()
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)
async def main(index): channel = Channel('127.0.0.1', 50051) client = DemoServiceStub(channel) response: demo_pb2.ResponseData = await client.ApiCreate( demo_pb2.RequestData(data="call ApiCreate from client " + str(index), ) ) print(response.return_code, response.message, response.data) # response: demo_pb2.ResponseData = await client.ApiList(demo_pb2.RequestData( # data="call ApiList from client", # )) # print(response.return_code, response.message, response.data) # # response: demo_pb2.ResponseData = await client.ApiUpdate(demo_pb2.RequestData( # data="call ApiUpdate from client", # )) # print(response.return_code, response.message, response.data) # # response: demo_pb2.ResponseData = await client.ApiDelete(demo_pb2.RequestData( # data="call ApiDelete from client", # )) # print(response.return_code, response.message, response.data) channel.close()
async def _wait_for_channel( host: str, port: int, timeout: float = CONNECTION_TIMEOUT, ssl_context: Optional[ssl.SSLContext] = None, ) -> Channel: logger.debug('Starting service health check') request = HealthCheckRequest() request.service = '' # empty service name for a server check deadline = time.time() + timeout while time.time() < deadline: channel = Channel(host, port, ssl=ssl_context, loop=asyncio.get_event_loop()) client = HealthStub(channel) try: response = await client.Check(request) if response.status == HealthCheckResponse.SERVING: logger.debug('Service health check completed with success') return channel except (StreamTerminatedError, ConnectionError): pass channel.close() sleep_time = 0.1 logger.debug( 'Service health check failed, will try again in %fs. deadline=%r', sleep_time, deadline, ) await asyncio.sleep(sleep_time) raise TimeoutError
async def connect( self, destination: ConnectionDestination, metadata: Optional[Dict[str, str]] = None, ) -> CompanionInfo: self.logger.debug(f"Connecting directly to {destination} with meta {metadata}") if isinstance(destination, Address): channel = Channel( destination.host, destination.port, loop=asyncio.get_event_loop() ) stub = CompanionServiceStub(channel=channel) with tempfile.NamedTemporaryFile(mode="w+b") as f: response = await stub.connect( ConnectRequest( destination=destination_to_grpc(destination), metadata=metadata, local_file_path=f.name, ) ) companion = CompanionInfo( udid=response.companion.udid, host=destination.host, port=destination.port, is_local=response.companion.is_local, ) self.logger.debug(f"Connected directly to {companion}") self.direct_companion_manager.add_companion(companion) channel.close() return companion else: companion = await self.spawn_companion(target_udid=destination) if companion: return companion else: raise IdbException(f"can't find target for udid {destination}")
class LightningStub(LoggerMixin): """lightning stub manager""" def __init__(self): self._host = os.environ.get("LND_HOST") self._port = int(os.environ.get("LND_PORT")) self._network = os.environ.get("NETWORK") self.id_pubkey = None self.stub = None os.environ["GRPC_SSL_CIPHER_SUITES"] = "HIGH+ECDSA" os.environ["SSL_CERT_DIR"] = "/root/.lnd" with open( f"/root/.lnd/data/chain/bitcoin/{self._network}/admin.macaroon", "rb") as macaroon_bytes: self._macaroon = macaroon_bytes.read().hex() ctx = ssl.SSLContext(ssl.PROTOCOL_TLS) ctx.verify_mode = ssl.CERT_REQUIRED ctx.load_verify_locations(cafile="/root/.lnd/tls.cert") # can take second arg path the private key str(client_key) ctx.load_cert_chain("/root/.lnd/tls.cert", "/root/.lnd/tls.key") # ctx.load_verify_locations(str(trusted)) WE TRUST THE CERTIFICATE ctx.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1 ctx.set_ciphers("ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20") ctx.set_alpn_protocols(["h2"]) try: ctx.set_npn_protocols(["h2"]) except NotImplementedError: pass self._channel = Channel(self._host, self._port, ssl=ctx) async def attach_metadata(event: SendRequest): event.metadata["macaroon"] = self._macaroon listen(self._channel, SendRequest, attach_metadata) async def initialize(self) -> None: """asynchronously init class and populate pubkey""" # TODO add wallet unlocking stub for wallet unlock # TODO max receive message length? = 1024^3 i = 1 while True: try: self.logger.info(f"Attempt ${i} to initialize lnd") self.stub = lnrpc.LightningStub(self._channel) req = ln.GetInfoRequest() info = await self.stub.GetInfo(req) self.id_pubkey = info.identity_pubkey assert self.id_pubkey self.logger.info("Success") break except (ConnectionRefusedError, gaierror) as error: i += 1 self.logger.info(f"Attempt failed: {error}") await asyncio.sleep(5) def destroy(self) -> None: self._channel.close()
async def green() -> dict: green_channel = Channel(host="127.0.0.1", port=50052) service = GreenStub(green_channel) response = await service.green() green_channel.close() print(response.to_dict()) return response.to_dict()
async def build( cls, address: Address, logger: logging.Logger, is_local: Optional[bool] = None, exchange_metadata: bool = True, extra_metadata: Optional[Dict[str, str]] = None, use_tls: bool = False, ) -> AsyncGenerator["Client", None]: metadata_to_companion = ( { **{ key: value for (key, value) in plugin.resolve_metadata(logger=logger).items() if isinstance(value, str) }, **(extra_metadata or {}), } if exchange_metadata else {} ) ssl_context = plugin.channel_ssl_context() if use_tls else None if use_tls: assert ssl_context is not None async with ( Channel( host=address.host, port=address.port, loop=asyncio.get_event_loop(), ssl=ssl_context, ) if isinstance(address, TCPAddress) else Channel(path=address.path, loop=asyncio.get_event_loop()) ) as channel: stub = CompanionServiceStub(channel=channel) with tempfile.NamedTemporaryFile(mode="w+b") as f: try: response = await stub.connect( ConnectRequest( metadata=metadata_to_companion, local_file_path=f.name ) ) except Exception as ex: raise IdbException( f"Failed to connect to companion at address {address}: {ex}" ) companion = companion_to_py( companion=response.companion, address=address, is_local=is_local ) if exchange_metadata: metadata_from_companion = { key: value for (key, value) in companion.metadata.items() if isinstance(value, str) } plugin.append_companion_metadata( logger=logger, metadata=metadata_from_companion ) yield Client(stub=stub, companion=companion, logger=logger)
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()
async def main(): channel = Channel('127.0.0.1', 19999) srvc = TestMathStub(channel) reply: BinaryOpResp = await srvc.Add(BinaryOpReq(i1=1, i2=1)) print(reply.result) channel.close()
async def run_info(address, port): channel = Channel(address, port) stub = gym_grpc.AgentStub(channel) info_reply = await call_info(stub) channel.close() return info_reply
async def main() -> None: channel = Channel('127.0.0.1', 50051) greeter = GreeterStub(channel) reply: HelloReply = await greeter.SayHello(HelloRequest(name='Dr. Strange')) print(reply.message) channel.close()
def __init__(self, server_url: str, **kwargs): self._server_url = server_url parsed = urlparse(self._server_url) self._username = parsed.username or '' self._password = parsed.password or '' host, p = parsed.netloc.split(':') port = int(p) self._channel = Channel(host, port, **kwargs) self.handlers = {}
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)
async def _get_ssh_key(self, ip_addr): channel = Channel(ip_addr, self._ee_service_port) try: stub = FrontendExecutorStub(channel) self.log.debug("get ssh key, ip_addr: {}".format(ip_addr)) reply: SshKeyReply = await stub.GetSshKey(SshKeyRequest()) return reply.message finally: channel.close()
def server(socket, use_ssl=False): channel = Channel(path=socket, ssl=use_ssl) client = PoreRefinerStub(channel) try: yield client except GRPCError as e: raise finally: channel.close()
async def main() -> None: channel = Channel('127.0.0.1', 50051) listen(channel, SendRequest, on_send_request) stub = GreeterStub(channel) response = await stub.SayHello(HelloRequest(name='World')) print(response.message) channel.close()
async def rec() -> dict: recommendations_channel = Channel(host="127.0.0.1", port=50051) service = RecommendationsStub(recommendations_channel) response = await service.recommend(user_id=1, category=BookCategory.MYSTERY, max_results=3) recommendations_channel.close() return response.to_dict()
async def _companion_to_target( self, companion: CompanionInfo) -> TargetDescription: 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)
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