def attach_middlewares(
server: Server,
api_token: str = "",
api_token_header: str = API_TOKEN_HEADER,
peer_whitelist: List[Union[IPv4Network, IPv6Network]] = [],
):
if api_token and api_token_header:
logger.info("api token middleware attached")
else:
logger.info("api token middleware NOT attached")
if peer_whitelist:
logger.info(f"peer whitelist middleware attached with networks: {peer_whitelist}")
else:
logger.info("peer whitelist middleware NOT attached")
async def recv_request(event: RecvRequest):
# Middlewares called in reversed order
if api_token and api_token_header:
attach_token_auth(event, api_header=api_token_header, api_token=api_token)
if peer_whitelist:
attach_check_peer_method(event, address_whitelist=peer_whitelist)
listen(server, RecvRequest, recv_request)
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 main(*, host: str = '127.0.0.1', port: int = 50051) -> None:
server = Server([Greeter()])
listen(server, RecvRequest, on_recv_request)
with graceful_exit([server]):
await server.start(host, port)
print(f'Serving on {host}:{port}')
await server.wait_closed()
async def test_dispatch():
class MyEvent(_Event, metaclass=_EventMeta):
__payload__ = ('a', 'b')
a: int
b: str
c: int
d: str
class MyDispatch(_Dispatch, metaclass=_DispatchMeta):
@_dispatches(MyEvent)
async def my_event(self, a, b, *, c, d):
return await self.__dispatch__(MyEvent(a=a, b=b, c=c, d=d))
class Target:
__dispatch__ = MyDispatch()
assert Target.__dispatch__.my_event is _ident
assert await Target.__dispatch__.my_event(1, 3, c=6, d=9) == (1, 3)
@mock_callback
async def callback(event: MyEvent):
assert event.a == 2
assert event.b == 4
assert event.c == 8
assert event.d == 16
listen(Target, MyEvent, callback)
assert Target.__dispatch__.my_event is not _ident
assert await Target.__dispatch__.my_event(2, 4, c=8, d=16) == (2, 4)
with patch_event():
callback.assert_called_once_with(MyEvent(a=2, b=4, c=8, d=16))
async def main() -> None:
async with Channel('127.0.0.1', 50051) as channel:
listen(channel, SendRequest, on_send_request)
stub = GreeterStub(channel)
response = await stub.SayHello(HelloRequest(name='World'))
print(response.message)
async def main(*, host='127.0.0.1', port=50051):
loop = asyncio.get_running_loop()
server = Server([Greeter()], loop=loop)
listen(server, RecvRequest, recv_request)
with graceful_exit([server], loop=loop):
await server.start(host, port)
print(f'Serving on {host}:{port}')
await server.wait_closed()
def configure(self, value: grpc_pb2.Server):
assert isinstance(value, grpc_pb2.Server), type(value)
self._config = value
handlers = list(self.handlers)
if not any(isinstance(h, Health) for h in handlers):
handlers.append(Health())
handlers = ServerReflection.extend(handlers)
self.server = Server(handlers)
listen(self.server, RecvRequest, _recv_request)
listen(self.server, SendTrailingMetadata, _send_trailing_metadata)
async def _test(event_type):
service = DummyService()
events = []
async def callback(event_):
events.append(event_)
async with ChannelFor([service]) as channel:
listen(channel, event_type, callback)
stub = DummyServiceStub(channel)
reply = await stub.UnaryUnary(DummyRequest(value='ping'),
timeout=1,
metadata={'request': 'true'})
assert reply == DummyReply(value='pong')
event, = events
return event
async def _test(event_type):
service = DummyService()
events = []
async def callback(event_):
events.append(event_)
channel_for = ChannelFor([service])
async with channel_for as channel:
server = channel_for._server
listen(server, event_type, callback)
stub = DummyServiceStub(channel)
reply = await stub.UnaryUnary(DummyRequest(value='ping'),
timeout=1,
metadata={'foo': 'bar'})
assert reply == DummyReply(value='pong')
event, = events
return event
async def test_interrupt():
class MyEvent(_Event, metaclass=_EventMeta):
payload: int
class MyDispatch(_Dispatch, metaclass=_DispatchMeta):
@_dispatches(MyEvent)
async def my_event(self, *, payload):
return await self.__dispatch__(MyEvent(payload=payload))
class Target:
__dispatch__ = MyDispatch()
@mock_callback
async def cb1(_: MyEvent):
pass
@mock_callback
async def cb2(event: MyEvent):
event.interrupt()
@mock_callback
async def cb3(_: MyEvent):
pass
listen(Target, MyEvent, cb1)
listen(Target, MyEvent, cb2)
listen(Target, MyEvent, cb3)
assert await Target.__dispatch__.my_event(payload=42) == ()
cb1.assert_called_once()
cb2.assert_called_once()
assert not cb3.called
async def _start_grpc_server(self):
self.grpc_server = Server([AioShadowsocksServicer()], loop=self.loop)
listen(self.grpc_server, RecvRequest, logging_grpc_request)
await self.grpc_server.start(self.grpc_host, self.grpc_port)
logging.info(f"Start grpc Server on {self.grpc_host}:{self.grpc_port}")
def configure(self, value: grpc_pb2.Channel):
assert isinstance(value, grpc_pb2.Channel), type(value)
self.channel = Channel(value.address.host, value.address.port)
listen(self.channel, SendRequest, _send_request)
listen(self.channel, RecvTrailingMetadata, _recv_trailing_metadata)
