def post(self,
url: str,
loop: "asyncio.AbstractEventLoop",
data: "Any" = None,
headers: "Optional[Dict[str, str]]" = None,
params: "Optional[Dict[str, str]]" = None,
timeout: "Optional[float]" = None,
verify: "Optional[bool]" = None,
**kwargs: "Any") -> MsalTransportResponse:
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
request.headers[
"Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
future = asyncio.run_coroutine_threadsafe( # type: ignore
self._pipeline.run(request,
connection_timeout=timeout,
connection_verify=verify,
**kwargs), loop)
response = future.result(timeout=timeout)
return MsalTransportResponse(response)
def _set_body(
content: ContentType,
data: dict,
files: Any,
json_body: Any,
internal_request: _PipelineTransportHttpRequest,
) -> None:
if data is not None and not isinstance(data, dict):
content = data
data = None
if content is not None:
_set_content_body(content, internal_request)
elif json_body is not None:
internal_request.set_json_body(json_body)
_set_content_type_header("application/json", internal_request)
elif files is not None:
internal_request.set_formdata_body(files)
# if you don't supply your content type, we'll create a boundary for you with multipart/form-data
# boundary = binascii.hexlify(os.urandom(16)).decode(
# "ascii"
#) # got logic from httpx, thanks httpx!
# _set_content_type_header("multipart/form-data; boundary={}".format(boundary), internal_request)
elif data:
_set_content_type_header("application/x-www-form-urlencoded",
internal_request)
internal_request.set_formdata_body(data)
# need to set twice because Content-Type is being popped in set_formdata_body
# don't want to risk changing pipeline.transport, so doing twice here
_set_content_type_header("application/x-www-form-urlencoded",
internal_request)
def _convert_request(request, files=None):
data = request.content if not files else None
request = HttpRequest(method=request.method,
url=request.url,
headers=request.headers,
data=data)
if files:
request.set_formdata_body(files)
return request
async def test_retry_seekable_file():
class MockTransport(AsyncHttpTransport):
def __init__(self):
self._first = True
async def __aexit__(self, exc_type, exc_val, exc_tb):
pass
async def close(self):
pass
async def open(self):
pass
async def send(
self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
if self._first:
self._first = False
for value in request.files.values():
name, body = value[0], value[1]
if name and body and hasattr(body, 'read'):
body.seek(0, 2)
raise AzureError('fail on first')
for value in request.files.values():
name, body = value[0], value[1]
if name and body and hasattr(body, 'read'):
position = body.tell()
assert not position
response = HttpResponse(request, None)
response.status_code = 400
return response
file = tempfile.NamedTemporaryFile(delete=False)
file.write(b'Lots of dataaaa')
file.close()
http_request = HttpRequest('GET', 'http://127.0.0.1/')
headers = {'Content-Type': "multipart/form-data"}
http_request.headers = headers
with open(file.name, 'rb') as f:
form_data_content = {
'fileContent': f,
'fileName': f.name,
}
http_request.set_formdata_body(form_data_content)
http_retry = AsyncRetryPolicy(retry_total=1)
pipeline = AsyncPipeline(MockTransport(), [http_retry])
await pipeline.run(http_request)
os.unlink(f.name)
def _prepare_request(
self,
method="POST", # type: Optional[str]
headers=None, # type: Optional[Mapping[str, str]]
form_data=None, # type: Optional[Mapping[str, str]]
params=None, # type: Optional[Dict[str, str]]
):
# type: (...) -> HttpRequest
request = HttpRequest(method, self._auth_url, headers=headers)
if form_data:
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(form_data)
if params:
request.format_parameters(params)
return request
def post(self, url, params=None, data=None, headers=None, **kwargs): # pylint:disable=unused-argument
# type: (str, Optional[Dict[str, str]], RequestData, Optional[Dict[str, str]], **Any) -> MsalResponse
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
if isinstance(data, dict):
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
elif isinstance(data, six.text_type):
body_bytes = six.ensure_binary(data)
request.set_bytes_body(body_bytes)
else:
raise ValueError('expected "data" to be text or a dict')
response = self._pipeline.run(request, stream=False, retry_on_methods=_POST)
self._store_auth_error(response)
return MsalResponse(response)
def test_retry_seekable_file():
class MockTransport(HttpTransport):
def __init__(self):
self._first = True
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def close(self):
pass
def open(self):
pass
def send(self, request,
**kwargs): # type: (PipelineRequest, Any) -> PipelineResponse
if self._first:
self._first = False
for value in request.files.values():
name, body = value[0], value[1]
if name and body and hasattr(body, 'read'):
body.seek(0, 2)
raise AzureError('fail on first')
for value in request.files.values():
name, body = value[0], value[1]
if name and body and hasattr(body, 'read'):
position = body.tell()
assert not position
return HttpResponse(request, None)
file_name = 'test_retry_seekable_file'
with open(file_name, "w+") as f:
f.write('Lots of dataaaa')
http_request = HttpRequest('GET', 'http://127.0.0.1/')
headers = {'Content-Type': "multipart/form-data"}
http_request.headers = headers
form_data_content = {
'fileContent': open(file_name, 'rb'),
'fileName': file_name,
}
http_request.set_formdata_body(form_data_content)
http_retry = RetryPolicy(retry_total=1)
pipeline = Pipeline(MockTransport(), [http_retry])
pipeline.run(http_request)
def post(
self,
url, # type: str
data=None, # type: Optional[Mapping[str, str]]
headers=None, # type: Optional[Mapping[str, str]]
params=None, # type: Optional[Dict[str, str]]
timeout=None, # type: float
verify=None, # type: bool
**kwargs # type: Any
):
# type: (...) -> MsalTransportResponse
request = HttpRequest("POST", url, headers=headers)
if params:
request.format_parameters(params)
if data:
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
request.set_formdata_body(data)
response = self._pipeline.run(
request, stream=False, connection_timeout=timeout, connection_verify=verify, **kwargs
)
return MsalTransportResponse(response)
