def __post_init__(self):
if not self.tls_ca_cert and self.tls_ca_cert_path:
with open(self.tls_ca_cert_path, 'rb') as inf:
self.tls_ca_cert = inf.read()
if not self.client_cert and self.client_cert_path:
with open(self.client_cert_path, 'rb') as inf:
self.client_cert = inf.read()
if not self.client_key and self.client_key_path:
with open(self.client_key_path, 'rb') as inf:
self.client_key = inf.read()
opts = [
("grpc.ssl_target_name_override", self.ssl_target_name)
] if self.ssl_target_name else []
# pylint: disable=attribute-defined-outside-init
# Create GRPC channel
if self.tls_ca_cert:
# Add client credentials if available
if self.client_cert and self.client_key:
creds = aiogrpc.ssl_channel_credentials(
self.tls_ca_cert,
private_key=self.client_key,
certificate_chain=self.client_cert
)
else:
creds = aiogrpc.ssl_channel_credentials(self.tls_ca_cert)
# Create secure channel
self._grpc_channel = aiogrpc.secure_channel(
self.endpoint, creds, opts
)
else:
# Create insecure channel if no cert
self._grpc_channel = aiogrpc.insecure_channel(self.endpoint, opts)
def _create_grpc_channel(self, endpoint, ssl=False,
ca_cert=None, cert_key=None, cert_cert=None, default_ca=False, options=None,
*, loop=None, executor=None):
credentials = None
if not ssl:
channel = aiogrpc.insecure_channel(endpoint, options=options, loop=loop, executor=executor,
standalone_pool_for_streaming=True)
else:
if default_ca:
ca_cert = None
else:
if ca_cert is None:
logger.warning("Certificate authority is not specified. Empty CA will be used. To use system CA set"
" `default_ca=True`")
ca_cert = ''
# to ensure ssl connect , set grpc env
# os.environ['GRPC_SSL_CIPHER_SUITES'] = 'ECDHE-ECDSA-AES256-GCM-SHA384'
credentials = aiogrpc.ssl_channel_credentials(ca_cert, cert_key, cert_cert)
channel = aiogrpc.secure_channel(endpoint, credentials, options=options,
loop=loop, executor=executor,
standalone_pool_for_streaming=True)
# Save parameters for auto-recreate
self._credentials = credentials
self._options = options
self._loop = channel._loop
self._executor = executor
return channel
def _recreate_grpc_channel(self, endpoint):
self._call_credentials = None
self._metadata = None
if self._credentials:
channel = aiogrpc.secure_channel(endpoint, self._credentials, options=self._options,
loop=self._loop, executor=self._executor,
standalone_pool_for_streaming=True)
else:
channel = aiogrpc.insecure_channel(endpoint, options=self._options, loop=self._loop,
executor=self._executor, standalone_pool_for_streaming=True)
return channel
def _connect_backend(self):
"""
Initializes the connection to the running backend
"""
if self.secure:
# For now just allow insecure connections
raise NotImplementedError()
#: gRPC channel
self._channel = aiogrpc.insecure_channel(
"{}:{}".format(self.host, self.port)
)
async def _connect_backend(self):
"""
Initializes the connection to the running backend
"""
#: gRPC channel
self._channel = aiogrpc.insecure_channel("{}:{}".format(
self.host, self.port))
print("Waiting for mavsdk_server to be ready...")
await aiogrpc.channel_ready_future(self._channel)
print("Connected to mavsdk_server!")
def create_grpc_channel(target,
cert_file=None,
client_key=None,
client_cert=None,
opts=None):
"""Construct a grpc channel.
Args:
target: server address include host:port
cert_file: ssl/tls root cert file for the connection
opts: grpc channel options
grpc.default_authority: default authority
grpc.ssl_target_name_override: ssl target name override
Returns:
grpc channel
"""
root_cert = None
if cert_file:
if isinstance(cert_file, bytes):
root_cert = cert_file
else:
with open(cert_file, 'rb') as f:
root_cert = f.read()
if client_key:
if not isinstance(client_key, bytes):
with open(client_key, 'rb') as f:
client_key = f.read()
if client_cert:
if not isinstance(client_cert, bytes):
with open(client_cert, 'rb') as f:
client_cert = f.read()
if root_cert is None:
return aiogrpc.insecure_channel(target, opts)
else:
if client_cert and client_key:
creds = aiogrpc. \
ssl_channel_credentials(root_cert,
private_key=client_key,
certificate_chain=client_cert)
else:
creds = aiogrpc.ssl_channel_credentials(root_cert)
return aiogrpc.secure_channel(target, creds, opts)
def __init__(self, file):
self.c = c = u.config
self.p = p = c["processes"][file]
u.delfile(f'.logs/{file}.txt')
self.logger = u.log = u.setLogger(p.get("loggers")).classFilter(
self, "main")
h = c["exchange"]
channel = insecure_channel('%s:%s' % (h["host"], h["port"]))
self._stub = ExchangeServiceStub(channel)
self.connections = {}
self.slowdown = 0
self.rtt = c["rtt"] # round-trip time
def __init__(self, broker='192.168.4.239:50052', *args, **kwargs):
self.broker = broker
self.channel = grpc.insecure_channel(self.broker)
self.async_channel = insecure_channel(self.broker)
self._event_thread = Thread(target=self.event_notify, name='EVENT')
self._callback_thread = Thread(target=self.callback, name='CALLBACK')
self._quotation_thread = Thread(target=self.quotation,
name='Quotation')
self._callback_thread_alive = True
self._quotation_thread_alive = True
self._callback_queue = queue.Queue()
self._event_loop = asyncio.get_event_loop()
self._sub_code = []
self._res = queue.Queue(maxsize=100)
async def member_healthy(self, members=None):
if not members:
members = await self.member_list()
members = [m.clientURLs for m in members]
health_members = []
unhealth_members = []
for m in members:
m = [u.rpartition("//")[2] for u in m]
m = [u for u in m if u]
if m:
server_endpoint = ipv4_endpoints(m)
if self._credentials:
channel = aiogrpc.secure_channel(
server_endpoint,
self._credentials,
options=self._options,
loop=self._loop,
executor=self._executor,
standalone_pool_for_streaming=True)
else:
channel = aiogrpc.insecure_channel(
server_endpoint,
options=self._options,
loop=self._loop,
executor=self._executor,
standalone_pool_for_streaming=True)
try:
maintenance = Maintenance(channel=channel,
timeout=2,
username=self.username,
password=self.password)
try:
await maintenance.status()
except grpc.RpcError:
unhealth_members.append(m)
else:
health_members.append(m)
finally:
await channel.close()
else:
unhealth_members.append(m)
return health_members, unhealth_members
async def _connect_backend(self):
"""
Initializes the connection to the running backend
"""
#: gRPC channel
self._channel = aiogrpc.insecure_channel(
"{}:{}".format(self.host, self.port),
standalone_pool_for_streaming=True
)
logger = logging.getLogger(__name__)
logger.addHandler(logging.NullHandler()) # Avoid errors when user has not configured logging
logger.debug("Waiting for mavsdk_server to be ready...")
await aiogrpc.channel_ready_future(self._channel)
logger.debug("Connected to mavsdk_server!")
async def testBalancing(self):
s1 = create_server(['127.0.0.1:9902'])
s2 = create_server(['127.0.0.1:9903'])
self.channel = aiogrpc.insecure_channel(
'ipv4:///127.0.0.1:9902,127.0.0.1:9903', loop=self.loop)
self.stub = TestServiceStub(self.channel)
s1.start()
try:
result = await self.stub.NormalMethod(StandardRequest(name='test1')
)
self.assertEqual(result.message, 'test1')
finally:
s1.stop(None)
s2.start()
try:
result = await self.stub.NormalMethod(StandardRequest(name='test1')
)
self.assertEqual(result.message, 'test1')
finally:
s1.stop(None)
def __init__(self,
host='localhost',
port=2379,
ca_cert=None,
cert_key=None,
cert_cert=None,
timeout=None,
user=None,
password=None):
self._url = '{host}:{port}'.format(host=host, port=port)
cert_params = [c is not None for c in (cert_cert, cert_key)]
if ca_cert is not None:
if all(cert_params):
credentials = self._get_secure_creds(ca_cert, cert_key,
cert_cert)
self.uses_secure_channel = True
self.channel = aiogrpc.secure_channel(self._url, credentials)
elif any(cert_params):
# some of the cert parameters are set
raise ValueError(
'to use a secure channel ca_cert is required by itself, '
'or cert_cert and cert_key must both be specified.')
else:
credentials = self._get_secure_creds(ca_cert, None, None)
self.uses_secure_channel = True
self.channel = aiogrpc.secure_channel(self._url, credentials)
else:
self.uses_secure_channel = False
self.channel = aiogrpc.insecure_channel(self._url)
self.timeout = timeout
self.call_credentials = None
self._user = user
self._password = password
def setUp(self):
self.loop = asyncio.get_event_loop()
self.channel = aiogrpc.insecure_channel('ipv4:///127.0.0.1:9901',
loop=self.loop)
self.stub = TestServiceStub(self.channel)
def _connect(self):
# connect to wavemq agent
wavemq_channel = insecure_channel(self._cfg['wavemq'])
self._cl = WAVEMQStub(wavemq_channel)
def __init__(self, host, port):
grpc_uri = f"ipv4:///{host}:{port}"
rpc_channel = insecure_channel(grpc_uri)
self.stub = InternalServerStub(rpc_channel)
async def query():
async with insecure_channel(url) as conn:
client = SquareServiceStub(channel=conn)
response = await client.sumSquare(
AsyncIterWrapper(Message(message=i) for i in range(12)))
print(response.message)
async def testAsyncCtxManager(self):
async with aiogrpc.insecure_channel('ipv4:///127.0.0.1:9901',
loop=self.loop) as _channel:
await aiogrpc.channel_ready_future(_channel)
async def query():
async with insecure_channel(url) as conn:
client = SquareServiceStub(channel=conn)
async for response in client.streamrangeSquare(
AsyncIterWrapper(Message(message=i) for i in range(12))):
print(response.message)
async def query():
async with insecure_channel(url) as conn:
client = SquareServiceStub(channel=conn)
result = await client.square(Message(message=12.3))
print(result)
from aiogrpc import insecure_channel
import asyncio
import stock_hq_pb2
import stock_hq_pb2_grpc
channel = insecure_channel('ipv4:///192.168.4.239:50052')
stub = stock_hq_pb2_grpc.StockHQServiceStub(channel)
async def test_call():
return await stub.QA_fetch_get(
stock_hq_pb2.Query(code='601801', type='1min'))
response = test_call()
print(response.code, response.open, response.high, response.low,
response.close)
#
#async def test_call_stream():
# async for v in mystub.my_stream_method(...):
# ...
async def __aenter__(self): self._channel = insecure_channel(self.endpoint) self._stub = prediction_service_pb2.beta_create_PredictionService_stub(self._channel) return self
async def query():
async with insecure_channel(url) as conn:
client = SquareServiceStub(channel=conn)
async for response in client.rangeSquare(Message(message=12)):
print(response.message)
