/// <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); }