/// <summary>
/// Calls the API that makes the HTTP request to the server. Retries the HTTP request in certain cases. This is a asynchronous call.
/// </summary>
/// <param name="opCode">Operation Code</param>
/// <param name="path">Path of the file or directory</param>
/// <param name="requestData">byte array, offset and length of the data of http request</param>
/// <param name="responseData">byte array, offset and length of the data of http response. byte array should be initialized for chunked response</param>
/// <param name="quer">Headers for request</param>
/// <param name="client">ADLS Store CLient</param>
/// <param name="req">Request options containing RetryOption, timout and requestid </param>
/// <param name="resp">Contains the response message </param>
/// <param name="cancelToken">CAncellationToken to cancel the operation</param>
/// <returns>Tuple of Byte array containing the bytes returned from the server and number of bytes read from server</returns>
internal static async Task <Tuple <byte[], int> > MakeCallAsync(string opCode, string path,
ByteBuffer requestData, ByteBuffer responseData, QueryParams quer, AdlsClient client, RequestOptions req, OperationResponse resp, CancellationToken cancelToken)
{
if (!VerifyMakeCallArguments(opCode, path, requestData, quer, client, req, resp))
{
return(null);
}
string uuid = req.RequestId;
int numRetries = 0;
Tuple <byte[], int> retVal;
do
{
resp.Reset();
req.RequestId = uuid + "." + numRetries;
resp.Retries = numRetries;
Stopwatch watch = Stopwatch.StartNew();
retVal = await MakeSingleCallAsync(opCode, path, requestData, responseData, quer, client, req, resp, cancelToken).ConfigureAwait(false);
watch.Stop();
resp.LastCallLatency = watch.ElapsedMilliseconds;
HandleMakeSingleCallResponse(opCode, path, resp, retVal?.Item2 ?? 0, requestData.Count, req.RequestId, client.ClientId, quer.Serialize(opCode), ref numRetries);
if (resp.Ex is OperationCanceledException)//Operation is cancelled then no retries
{
break;
}
} while (!resp.IsSuccessful && req.RetryOption.ShouldRetry((int)resp.HttpStatus, resp.Ex));
resp.OpCode = opCode;
return(retVal);
}
/// <summary>
/// Calls the API that makes the HTTP request to the server. Retries the HTTP request in certain cases. This is a synchronous call.
/// </summary>
/// <param name="opCode">Operation Code</param>
/// <param name="path">Path of the file or directory</param>
/// <param name="requestData">byte array, offset and length of the data of http request</param>
/// <param name="responseData">byte array, offset and length of the data of http response. byte array should be initialized for chunked response</param>
/// <param name="quer">Headers for request</param>
/// <param name="client">ADLS Store CLient</param>
/// <param name="req">Request options containing RetryOption, timout and requestid </param>
/// <param name="resp">Contains the response message </param>
/// <param name="customHeaders">Dictionary containing the custom header that Core wants to pass</param>
/// <returns>Tuple of Byte array containing the bytes returned from the server and number of bytes read from server</returns>
internal static Tuple <byte[], int> MakeCall(string opCode, string path, ByteBuffer requestData, ByteBuffer responseData, QueryParams quer, AdlsClient client, RequestOptions req, OperationResponse resp, IDictionary <string, string> customHeaders = null)
{
if (!VerifyMakeCallArguments(opCode, path, requestData, quer, client, req, resp))
{
return(null);
}
string uuid = req.RequestId;
int numRetries = 0;
Tuple <byte[], int> retVal;
do
{
resp.Reset();
req.RequestId = uuid + "." + numRetries;
resp.Retries = numRetries;
Stopwatch watch = Stopwatch.StartNew();
retVal = MakeSingleCall(opCode, path, requestData, responseData, quer, client, req, resp, customHeaders);
watch.Stop();
resp.LastCallLatency = watch.ElapsedMilliseconds;
HandleMakeSingleCallResponse(opCode, path, resp, retVal?.Item2 ?? 0, requestData.Count, req, client, quer.Serialize(opCode), ref numRetries);
// If dip is used, this request is not ignoring dip, and there is a connection failure, then reset the DIP
if (client.DipIp != null && !req.IgnoreDip && resp.ConnectionFailure)
{
WebTransportLog.Debug("Connection Failure, DIP enabled, Resetting Dip");
client.UpdateDipAsync(default(CancellationToken)).GetAwaiter().GetResult();
}
} while (!resp.IsSuccessful && req.RetryOption.ShouldRetry((int)resp.HttpStatus, resp.Ex));
resp.OpCode = opCode;
return(retVal);
}
/// <summary>
/// Calls the API that makes the HTTP request to the server. Retries the HTTP request in certain cases. This is a asynchronous call.
/// </summary>
/// <param name="opCode">Operation Code</param>
/// <param name="path">Path of the file or directory</param>
/// <param name="requestData">byte array, offset and length of the data of http request</param>
/// <param name="responseData">byte array, offset and length of the data of http response. byte array should be initialized for chunked response</param>
/// <param name="quer">Headers for request</param>
/// <param name="client">ADLS Store CLient</param>
/// <param name="req">Request options containing RetryOption, timout and requestid </param>
/// <param name="resp">Contains the response message </param>
/// <param name="cancelToken">CancellationToken to cancel the operation</param>
/// <param name="customHeaders">Dictionary containing the custom header that Core wants to pass</param>
/// <returns>Tuple of Byte array containing the bytes returned from the server and number of bytes read from server</returns>
internal static async Task <Tuple <byte[], int> > MakeCallAsync(string opCode, string path,
ByteBuffer requestData, ByteBuffer responseData, QueryParams quer, AdlsClient client, RequestOptions req, OperationResponse resp, CancellationToken cancelToken, IDictionary <string, string> customHeaders = null)
{
if (!VerifyMakeCallArguments(opCode, path, requestData, quer, client, req, resp))
{
return(null);
}
string uuid = req.RequestId;
int numRetries = 0;
Tuple <byte[], int> retVal;
do
{
resp.Reset();
req.RequestId = uuid + "." + numRetries;
resp.Retries = numRetries;
Stopwatch watch = Stopwatch.StartNew();
retVal = await MakeSingleCallAsync(opCode, path, requestData, responseData, quer, client, req, resp, cancelToken, customHeaders).ConfigureAwait(false);
watch.Stop();
resp.LastCallLatency = watch.ElapsedMilliseconds;
HandleMakeSingleCallResponse(opCode, path, resp, retVal?.Item2 ?? 0, requestData.Count, req, client, quer.Serialize(opCode), ref numRetries);
if (resp.Ex is OperationCanceledException)//Operation is cancelled then no retries
{
break;
}
// If dip is used, this request is not ignoring dip, and there is a connection failure, then reset the DIP
if (client.DipIp != null && !req.IgnoreDip && resp.ConnectionFailure)
{
await client.UpdateDipAsync(cancelToken).ConfigureAwait(false);
}
} while (!resp.IsSuccessful && req.RetryOption.ShouldRetry((int)resp.HttpStatus, resp.Ex));
resp.OpCode = opCode;
return(retVal);
}
/// <summary>
/// Calls the API that makes the HTTP request to the server. Retries the HTTP request in certain cases. This is a synchronous call.
/// </summary>
/// <param name="opCode">Operation Code</param>
/// <param name="path">Path of the file or directory</param>
/// <param name="requestData">byte array, offset and length of the data of http request</param>
/// <param name="responseData">byte array, offset and length of the data of http response. byte array should be initialized for chunked response</param>
/// <param name="quer">Headers for request</param>
/// <param name="client">ADLS Store CLient</param>
/// <param name="req">Request options containing RetryOption, timout and requestid </param>
/// <param name="resp">Contains the response message </param>
/// <returns>Tuple of Byte array containing the bytes returned from the server and number of bytes read from server</returns>
internal static Tuple <byte[], int> MakeCall(string opCode, string path, ByteBuffer requestData, ByteBuffer responseData, QueryParams quer, AdlsClient client, RequestOptions req, OperationResponse resp)
{
if (!VerifyMakeCallArguments(opCode, path, requestData, quer, client, req, resp))
{
return(null);
}
string uuid = req.RequestId;
int numRetries = 0;
Tuple <byte[], int> retVal;
do
{
resp.Reset();
req.RequestId = uuid + "." + numRetries;
resp.Retries = numRetries;
Stopwatch watch = Stopwatch.StartNew();
retVal = MakeSingleCall(opCode, path, requestData, responseData, quer, client, req, resp);
watch.Stop();
resp.LastCallLatency = watch.ElapsedMilliseconds;
HandleMakeSingleCallResponse(opCode, path, resp, retVal?.Item2 ?? 0, requestData.Count, req.RequestId, client.ClientId, quer.Serialize(opCode), ref numRetries);
} while (!resp.IsSuccessful && req.RetryOption.ShouldRetry((int)resp.HttpStatus, resp.Ex));
resp.OpCode = opCode;
return(retVal);
}