def _create_appconfig_pipeline(self, credential, base_url=None, aad_mode=False, **kwargs):
transport = kwargs.get('transport')
policies = kwargs.get('policies')
if policies is None: # [] is a valid policy list
if aad_mode:
scope = base_url.strip("/") + "/.default"
if hasattr(credential, "get_token"):
credential_policy = AsyncBearerTokenCredentialPolicy(credential, scope)
else:
raise TypeError("Please provide an instance from azure-identity "
"or a class that implement the 'get_token protocol")
else:
credential_policy = AppConfigRequestsCredentialsPolicy(credential)
policies = [
self._config.headers_policy,
self._config.user_agent_policy,
credential_policy,
self._config.retry_policy,
SyncTokenPolicy(),
self._config.logging_policy, # HTTP request/response log
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = AsyncioRequestsTransport(**kwargs)
return AsyncPipeline(
transport,
policies,
)
async def test_async_transport_sleep():
async with AsyncioRequestsTransport() as transport:
await transport.sleep(1)
async with AioHttpTransport() as transport:
await transport.sleep(1)
async def test_send_data(port):
async with AsyncioRequestsTransport() as transport:
req = HttpRequest('PUT',
'http://localhost:{}/basic/anything'.format(port),
data=b"azerty")
response = await transport.send(req)
assert json.loads(response.text())['data'] == "azerty"
async def test_send_data(port):
async with AsyncioRequestsTransport() as transport:
client = AsyncTestRestClient(port, transport=transport)
request = HttpRequest('PUT', 'http://localhost:{}/basic/anything'.format(port), content=b"azerty")
response = await client.send_request(request)
assert response.json()['data'] == "azerty"
async def test_conf_async_requests():
request = HttpRequest("GET", "https://www.bing.com/")
async with AsyncioRequestsTransport() as sender:
response = await sender.send(request)
assert response.body() is not None
assert isinstance(response.status_code, int)
async def test_conf_async_requests():
conf = Configuration()
request = HttpRequest("GET", "https://www.bing.com/")
async with AsyncioRequestsTransport(conf) as sender:
response = await sender.send(request)
assert response.body() is not None
assert response.status_code == 200
async def test_conf_async_requests():
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AsyncioRequestsTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert isinstance(response.http_response.status_code, int)
async def test_conf_async_requests(port, http_request):
request = http_request("GET",
"http://localhost:{}/basic/string".format(port))
async with AsyncioRequestsTransport() as sender:
response = await sender.send(request)
assert response.body() is not None
assert isinstance(response.status_code, int)
async def test_conf_async_requests(port):
request = HttpRequest("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AsyncioRequestsTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert isinstance(response.http_response.status_code, int)
async def test_example_asyncio():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# [START asyncio]
from azure.core.pipeline.transport import AsyncioRequestsTransport
async with AsyncPipeline(AsyncioRequestsTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
# [END asyncio]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def _create_appconfig_pipeline(self):
policies = [
self.config.headers_policy,
self.config.user_agent_policy,
self.config.logging_policy, # HTTP request/response log
AppConfigRequestsCredentialsPolicy(self.config.credentials),
DistributedTracingPolicy()
]
return AsyncPipeline(
AsyncioRequestsTransport(configuration=self.config), # Send HTTP request using requests
policies,
)
def _build_pipeline(config: Configuration, transport: HttpTransport,
**kwargs: Any) -> AsyncPipeline:
policies = [
config.headers_policy, config.user_agent_policy,
config.proxy_policy, config.redirect_policy, config.retry_policy,
config.authentication_policy, config.logging_policy,
DistributedTracingPolicy()
]
if transport is None:
transport = AsyncioRequestsTransport(**kwargs)
return AsyncPipeline(transport, policies=policies)
def __init__(self,
config: "Optional[Configuration]" = None,
policies: "Optional[Iterable[HTTPPolicy]]" = None,
transport: "Optional[AsyncHttpTransport]" = None,
**kwargs: "Any") -> None:
config = config or self._create_config(**kwargs)
policies = policies or [
ContentDecodePolicy(),
config.retry_policy,
config.logging_policy,
DistributedTracingPolicy(),
]
if not transport:
transport = AsyncioRequestsTransport(**kwargs)
self._pipeline = AsyncPipeline(transport=transport, policies=policies)
super().__init__(**kwargs)
def _build_pipeline(config: Configuration,
transport: HttpTransport) -> AsyncPipeline:
policies = [
config.headers_policy,
config.user_agent_policy,
config.proxy_policy,
config.redirect_policy,
config.retry_policy,
config.authentication_policy,
config.logging_policy,
]
if transport is None:
transport = AsyncioRequestsTransport(config)
return AsyncPipeline(transport, policies=policies)
async def test_async_gen_data():
class AsyncGen:
def __init__(self):
self._range = iter([b"azerty"])
def __aiter__(self):
return self
async def __anext__(self):
try:
return next(self._range)
except StopIteration:
raise StopAsyncIteration
async with AsyncioRequestsTransport() as transport:
req = HttpRequest('GET', 'http://httpbin.org/post', data=AsyncGen())
await transport.send(req)
async def test_async_gen_data(port):
class AsyncGen:
def __init__(self):
self._range = iter([b"azerty"])
def __aiter__(self):
return self
async def __anext__(self):
try:
return next(self._range)
except StopIteration:
raise StopAsyncIteration
async with AsyncioRequestsTransport() as transport:
client = AsyncTestRestClient(port, transport=transport)
request = HttpRequest('GET', 'http://localhost:{}/basic/anything'.format(port), content=AsyncGen())
response = await client.send_request(request)
assert response.json()['data'] == "azerty"
async def test_async_gen_data(port):
class AsyncGen:
def __init__(self):
self._range = iter([b"azerty"])
def __aiter__(self):
return self
async def __anext__(self):
try:
return next(self._range)
except StopIteration:
raise StopAsyncIteration
async with AsyncioRequestsTransport() as transport:
req = HttpRequest('GET',
'http://localhost:{}/basic/anything'.format(port),
data=AsyncGen())
response = await transport.send(req)
assert json.loads(response.text())['data'] == "azerty"
def _create_appconfig_pipeline(self, **kwargs):
transport = kwargs.get('transport')
policies = kwargs.get('policies')
if policies is None: # [] is a valid policy list
policies = [
self.config.headers_policy,
self.config.user_agent_policy,
AppConfigRequestsCredentialsPolicy(self.config.credentials),
self.config.retry_policy,
self.config.logging_policy, # HTTP request/response log
DistributedTracingPolicy(),
]
if not transport:
transport = AsyncioRequestsTransport(**kwargs)
return AsyncPipeline(
transport,
policies,
)
def __init__(self, identity_service_url: str, **kwargs: Any) -> None: # pylint: disable=missing-client-constructor-parameter-credential
client = kwargs.get("generated_client")
if client:
# caller provided a configured client -> nothing left to initialize
self._client = client
return
try:
identity_service_url = identity_service_url.strip(" /")
if not identity_service_url.lower().startswith("https://"):
self._identity_service_url = "https://" + identity_service_url
else:
self._identity_service_url = identity_service_url
except AttributeError:
raise ValueError("Identity Service URL must be a string.")
self.api_version = kwargs.pop("api_version", DEFAULT_VERSION)
pipeline = kwargs.pop("pipeline", None)
transport = kwargs.pop("transport", AsyncioRequestsTransport(**kwargs))
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update(
{
"x-ms-keyvault-network-info",
"x-ms-keyvault-region",
"x-ms-keyvault-service-version",
}
)
authentication_policy = None
self._client = _ConfidentialLedgerIdentityServiceClient(
self._identity_service_url,
api_version=self.api_version,
pipeline=pipeline,
transport=transport,
authentication_policy=authentication_policy,
http_logging_policy=http_logging_policy,
**kwargs
)
def __init__(self,
vault_url,
credentials,
config=None,
api_version=None,
**kwargs):
if not credentials:
raise ValueError("credentials")
if not vault_url:
raise ValueError("vault_url")
self._vault_url = vault_url
if api_version is None:
api_version = KeyVaultClient.DEFAULT_API_VERSION
# TODO: need config to get default policies, config requires credentials but doesn't do anything with them
config = config or KeyVaultClient.get_configuration_class(
api_version, aio=True)(credentials)
# TODO generated default pipeline should be fine when token policy isn't necessary
policies = [
config.headers_policy,
config.user_agent_policy,
config.proxy_policy,
_BearerTokenCredentialPolicy(credentials),
config.redirect_policy,
config.retry_policy,
config.logging_policy,
]
transport = AsyncioRequestsTransport(config)
pipeline = AsyncPipeline(transport, policies=policies)
self._client = KeyVaultClient(credentials,
api_version=api_version,
pipeline=pipeline,
aio=True)
async def client(port):
async with AsyncioRequestsTransport() as transport:
async with AsyncTestRestClient(port, transport=transport) as client:
yield client
async def test_send_data():
async with AsyncioRequestsTransport() as transport:
req = HttpRequest('PUT', 'http://httpbin.org/anything', data=b"azerty")
response = await transport.send(req)
assert json.loads(response.text())['data'] == "azerty"
