public void SubmitBatchAndWait(IBatchRequest batch, bool urgent)
{
int completed = 0;
Dictionary <IRequest, BaseRequest.RequestCompletedCallback> callbacks = new Dictionary <IRequest, BaseRequest.RequestCompletedCallback>();
ManualResetEvent mre = new ManualResetEvent(false);
foreach (IRequest req in batch.Requests)
{
BaseRequest.RequestCompletedCallback _callback = req.RequestCompleteCallback;
callbacks.Add(req, _callback);
req.RequestCompleteCallback = delegate(IRequest r)
{
completed++;
callbacks[r](r);
if (completed >= batch.Requests.Count)
{
mre.Set();
}
};
SubmitRequest(req, false);
}
mre.WaitOne();
}
private void DoBatchRequest()
{
IBatchRequest req = _client.RequestManager.GetNextBatchRequest();
if (req == null)
{
return;
}
foreach (IRequest r in req.Requests)
{
DoRequest(r);
}
}
/// <summary>
/// Inserts a new batch request to the end of the pending requests list
/// </summary>
/// <param name="batch"></param>
/// <param name="urgent"></param>
public void SubmitBatchRequest(IBatchRequest batch, bool urgent)
{
InjectClient(batch.Requests.ToArray());
lock (_pendingBatchRequests)
{
if (urgent)
{
_pendingBatchRequests.Insert(0, batch);
}
else
{
_pendingBatchRequests.Add(batch);
}
}
}
public async Task <IReadOnlyList <Response> > BatchAsync(IBatchRequest request, CancellationToken cancellationToken = default, bool?notfoundIsSuccess = null)
{
var message = request.CreateMessage();
_credentialBuilder?.Build(_httpClient, message);
var response = await _httpClient.SendAsync(message, cancellationToken);
if (!response.Content.IsMimeMultipartContent())
{
return new[] { await ParseAsync(response.StatusCode, response.Content, response.Headers, notfoundIsSuccess ?? NotFoundIsSuccess) }
}
;
var multipart = await response.Content.ReadAsMultipartAsync(cancellationToken);
return(await ParseMultiAsync(multipart, response.Headers, cancellationToken, notfoundIsSuccess));
}
public async Task <IEnumerable <Response> > BatchAsync(IBatchRequest request)
{
var message = request.CreateMessage();
_credentialBuilder?.Build(_httpClient, message);
var response = await _httpClient.SendAsync(message);
if (!response.Content.IsMimeMultipartContent())
{
return new[] { await ParseAsync(response.StatusCode, response.Content, response.Headers) }
}
;
var multipart = await response.Content.ReadAsMultipartAsync();
return(await ParseMultiAsync(multipart, response.Headers));
}
public async Task <IEnumerable <Response> > BatchAsync(IBatchRequest request)
{
var message = request.CreateMessage();
message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_credentialBuilder?.Build(_httpClient, message);
var response = await _httpClient.SendAsync(message);
if (!response.Content.IsMimeMultipartContent())
{
return new[] { await ParseAsync(response.StatusCode, response.Content) }
}
;
var multipart = await response.Content.ReadAsMultipartAsync();
return(await ParseMultiAsync(multipart));
}
/// <summary>
/// Submits a batch of asynchronous requests
/// </summary>
/// <param name="batch"></param>
/// <param name="urgent"></param>
public void SubmitAsyncBatchRequest(IBatchRequest batch, bool urgent)
{
lock (_pendingRequests)
{
foreach (IRequest req in batch.Requests)
{
InjectClient(req);
if (urgent)
{
_pendingRequests.Insert(0, req);
}
else
{
_pendingRequests.Add(req);
}
}
}
}
/// <summary>
/// Gets the next pending batch request.
/// </summary>
/// <returns></returns>
public IBatchRequest GetNextBatchRequest()
{
IBatchRequest req = null;
lock (_pendingBatchRequests)
{
if (_pendingBatchRequests.Count == 0)
{
return(req);
}
req = _pendingBatchRequests[0];
_pendingBatchRequests.RemoveAt(0);
lock (_activeRequests)
{
foreach (IRequest r in req.Requests)
{
_activeRequests.Add(r);
}
}
}
return(req);
}
private void FolderDataCallback(IBatchRequest req)
{
foldersPopulated = true;
ColorConsole.WriteLine("^11:00Done\n");
}
public Task <IReadOnlyList <Response> > SendAsync(IBatchRequest batchRequest, CancellationToken cancellationToken = default, bool?notfoundIsSuccess = null)
{
return(BatchAsync(batchRequest, cancellationToken, notfoundIsSuccess));
}
public void SubmitBatchAndWait(IBatchRequest batch, bool urgent)
{
int completed = 0;
Dictionary<IRequest, BaseRequest.RequestCompletedCallback> callbacks = new Dictionary<IRequest, BaseRequest.RequestCompletedCallback>();
ManualResetEvent mre = new ManualResetEvent(false);
foreach (IRequest req in batch.Requests)
{
BaseRequest.RequestCompletedCallback _callback = req.RequestCompleteCallback;
callbacks.Add(req, _callback);
req.RequestCompleteCallback = delegate(IRequest r)
{
completed++;
callbacks[r](r);
if (completed >= batch.Requests.Count)
mre.Set();
};
SubmitRequest(req, false);
}
mre.WaitOne();
}
/// <summary>
/// Submits a batch of asynchronous requests
/// </summary>
/// <param name="batch"></param>
/// <param name="urgent"></param>
public void SubmitAsyncBatchRequest(IBatchRequest batch, bool urgent)
{
lock(_pendingRequests)
{
foreach (IRequest req in batch.Requests)
{
InjectClient(req);
if (urgent)
_pendingRequests.Insert(0, req);
else
_pendingRequests.Add(req);
}
}
}
/// <summary>
/// Inserts a new batch request to the end of the pending requests list
/// </summary>
/// <param name="batch"></param>
/// <param name="urgent"></param>
public void SubmitBatchRequest(IBatchRequest batch, bool urgent)
{
InjectClient(batch.Requests.ToArray());
lock (_pendingBatchRequests)
{
if (urgent)
_pendingBatchRequests.Insert(0, batch);
else
_pendingBatchRequests.Add(batch);
}
}
public async Task <BatchResult> BatchAsync(IBatchRequest request)
{
if (request == null || request.BatchRequests.Count <= 0)
{
throw new ArgumentNullException(nameof(request));
}
try
{
var resourceName = $"{request.Prefix}composite/batch";
if (request.HaltOnError)
{
if (request.BatchRequests.Count > Dnf.BatchLimit)
{
throw new ArgumentOutOfRangeException(nameof(request));
}
var inputObject = new JObject
{
["batchRequests"] = JToken.FromObject(request.BatchRequests.Select(req => Dnf.Assign(JObject.FromObject(req), new JObject
{
["url"] = DecodeReference($"/services/data/{ApiVersion}/{request.Prefix}{req.Url?.TrimStart('/')}")
}))),
["haltOnError"] = true
};
var result = await JsonHttp.HttpPostAsync <BatchResultBody>(inputObject, resourceName)
.ConfigureAwait(false);
var results = new BatchResult(request.BatchRequests, result?.Results ?? new List <BatchSubRequestResult>());
return(results);
}
else
{
var throttler = new SemaphoreSlim(Dnf.DefaultConcurrentLimit, Dnf.DefaultConcurrentLimit);
var results = new BatchResult();
var chunks = new List <IList <BatchSubRequest> >();
IList <BatchSubRequest>?chunk = null;
foreach (var req in request.BatchRequests)
{
var added = false;
if (chunk?.Count < Dnf.BatchLimit)
{
chunk.Add(req);
added = true;
}
if (added)
{
continue;
}
chunk = new List <BatchSubRequest> {
req
};
chunks.Add(chunk);
}
var tasks = new List <Task>();
foreach (var requests in chunks)
{
await throttler.WaitAsync()
.ConfigureAwait(false);
tasks.Add(Task.Run(async() =>
{
try
{
var inputObject = new JObject
{
["batchRequests"] = JToken.FromObject(requests.Select(req => Dnf.Assign(JObject.FromObject(req), new JObject
{
["url"] = DecodeReference($"/services/data/{ApiVersion}/{request.Prefix}{req.Url?.TrimStart('/')}")
})))
};
var result = await JsonHttp.HttpPostAsync <BatchResultBody>(inputObject, resourceName)
.ConfigureAwait(false);
results.Add(requests, result?.Results ?? new List <BatchSubRequestResult>());
}
catch (Exception ex)
{
var body = new JArray {
ex.Message
};
var responses = requests.Select(req => new BatchSubRequestResult
{
Result = body,
StatusCode = 500
}).ToList();
results.Add(requests, responses);
}
finally
{
throttler.Release();
}
}));
}
await Task.WhenAll(tasks)
.ConfigureAwait(false);
return(results);
}
}
catch (Exception ex)
{
var body = new JArray {
ex.Message
};
var responses = request.BatchRequests.Select(req => new BatchSubRequestResult
{
Result = body,
StatusCode = 500
}).ToList();
var results = new BatchResult(request.BatchRequests, responses);
return(results);
}
}
private void FolderDataCompleted(IBatchRequest req)
{
//UpdateProgressWindow(0, false);
UpdateFolderListState(true);
UpdateLabel("Folder data loaded.");
}
public async Task <IEnumerable <Response> > SendAsync(IBatchRequest batchRequest)
{
return(await BatchAsync(batchRequest));
}
private void FolderDataCompleted(IBatchRequest req)
{
//UpdateProgressWindow(0, false);
UpdateFolderListState(true);
UpdateLabel("Folder data loaded.");
}
