public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
foreach (var uri in ReplicaAddresses.OrderBy(x => random.Next()))
{
var webRequest = CreateRequest(uri + "?query=" + query);
var resultTask = ProcessRequestAsync(webRequest);
Console.WriteLine($"Processing {webRequest.RequestUri}");
Tasks.Add(resultTask);
if (TryCheckIfPreviousCompleted(out var completed))
{
Console.WriteLine($"While processing {webRequest.RequestUri} old task {completed.Id} was completed");
return(completed.Result);
}
await Task.WhenAny(resultTask, Task.Delay(GetSoftTimeout(timeout)));
if (resultTask.IsCompleted)
{
return(resultTask.Result);
}
}
// wait extra
Console.WriteLine($"Waiting extra than timeout {timeout.ToString()}");
var answered = await Task.WhenAny(Tasks);
if (answered.IsCompleted)
{
return(answered.Result);
}
// or do not wait excess
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var replica = ReplicaAddresses.ToList();
var priorityReplica = replica
.Select((t, i) => new Tuple <int, string>(Priority[i], t))
.ToList();
priorityReplica.Sort();
var timeoutOneTask = new TimeSpan(timeout.Ticks / ReplicaAddresses.Length);
for (var i = 0; i < priorityReplica.Count; i++)
{
var priorityReplicaAddress = priorityReplica[i];
var replicaAddress = priorityReplicaAddress.Item2;
var webRequest = CreateRequest(replicaAddress + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(timeoutOneTask));
if (!resultTask.IsCompleted || resultTask.IsFaulted)
{
Priority[i] += 1;
continue;
}
Priority[i] -= 1;
return(resultTask.Result);
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var webRequests = ReplicaAddresses.Select(uri => CreateRequest(uri + "?query=" + query)).ToList();
var resultTasks = new List <Task <string> >();
foreach (var request in webRequests)
{
Log.InfoFormat("Processing {0}", request.RequestUri);
resultTasks.Add(ProcessRequestAsync(request));
}
var result = Task.WhenAny(resultTasks);
await Task.WhenAny(result, Task.Delay(timeout));
if (!result.IsCompleted && !result.IsFaulted)
{
throw new TimeoutException();
}
for (var i = 0; i < resultTasks.Count; i++)
{
if (resultTasks[i].IsCompleted)
{
continue;
}
var cancellation = CreateRequest(ReplicaAddresses[i] + "?query=" + query);
cancellation.Method = "DELETE";
ProcessRequestAsync(cancellation);
}
return(result.Result.Result);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
if (Cache.ContainsKey(query))
{
return(Cache[query]);
}
var webRequests = ReplicaAddresses.Select(uri => CreateRequest(uri + "?query=" + query));
var resultTasks = new List <Task <string> >();
foreach (var request in webRequests)
{
Log.InfoFormat("Processing {0}", request.RequestUri);
resultTasks.Add(ProcessRequestAsync(request));
}
var resultTask = Task.WhenAny(resultTasks);
await Task.WhenAny(resultTask, Task.Delay(timeout));
if (!resultTask.IsCompleted && !resultTask.IsFaulted)
{
throw new TimeoutException();
}
var requestResult = resultTask.Result.Result;
Cache[query] = requestResult;
return(requestResult);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
timeout = TimeSpan.FromSeconds(timeout.TotalSeconds / ReplicaAddresses.Length);
var orderedAddresses = ReplicaAddresses.OrderBy(addr => requestStatistics[addr].GetValue()).ToArray();
foreach (var uri in orderedAddresses)
{
var request = CreateRequest(uri + "?query=" + query);
Log.InfoFormat("Processing {0}", request.RequestUri);
timer.Start();
var task = ProcessRequestAsync(request);
await Task.WhenAny(task, Task.Delay(timeout));
timer.Stop();
requestStatistics[uri].Update(timer.ElapsedMilliseconds);
timer.Reset();
if (task.IsCompleted && !task.IsFaulted)
{
return(task.Result);
}
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var replica = ReplicaAddresses.ToArray();
replica.Shuffle(rand);
foreach (var s in replica)
{
Console.Write(s + " ");
}
Console.WriteLine();
var timeoutOneTask = new TimeSpan(timeout.Ticks / ReplicaAddresses.Length);
foreach (var replicaAddress in replica)
{
var webRequest = CreateRequest(replicaAddress + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(timeoutOneTask));
if (!resultTask.IsCompleted)
{
continue;
}
if (resultTask.IsFaulted)
{
continue;
}
return(resultTask.Result);
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
timeout = TimeSpan.FromSeconds(timeout.TotalSeconds / ReplicaAddresses.Length);
var shuffledAddresses = ReplicaAddresses.Shuffle();
var filtredAddresses = shuffledAddresses.Where(server => DateTime.Now - mutedServers[server] > TimeInBan).ToList();
if (filtredAddresses.Count == 0)
{
filtredAddresses = shuffledAddresses.OrderBy(server => DateTime.Now - mutedServers[server]).ToList();
}
var webRequests = filtredAddresses.Select(uri => CreateRequest(uri + "?query=" + query));
foreach (var request in webRequests)
{
Log.InfoFormat("Processing {0}", request.RequestUri);
var task = ProcessRequestAsync(request);
await Task.WhenAny(task, Task.Delay(timeout));
if (task.IsCompleted && !task.IsFaulted)
{
return(task.Result);
}
mutedServers[request.Host] = DateTime.Now;
}
throw new TimeoutException();
}
public IEnumerable <string> RandomizeReplicas()
{
var replicasToList = ReplicaAddresses.ToList();
while (replicasToList.Count > 0)
{
var uri = replicasToList[new Random().Next(replicasToList.Count)];
replicasToList.Remove(uri);
yield return(uri);
}
}
protected override async Task <string> ProcessRequestAsyncInternal(string query, TimeSpan timeout)
{
// в случаае, если одна реплика не работает, то ъждать ответа от остальных
var tasks = ReplicaAddresses.Select(async addr =>
{
var request = CreateRequest($"{addr}?query={query}", timeout);
return(await ProcessRequestAsync(request).WithTimeout(timeout));
});
return(await await TaskExtensions.WhenAnySucceded(tasks));
}
protected override async Task <string> ProcessRequestAsyncInternal(string query, TimeSpan timeout)
{
var batchCount = Math.Ceiling((double)ReplicaAddresses.Length / batchSize);
var singleBatchTimeout = TimeSpan.FromMilliseconds(timeout.TotalMilliseconds / batchCount);
var requests = ReplicaAddresses
.RandomSubset(ReplicaAddresses.Length)
.Select(addr => CreateRequest($"{addr}?query={query}", timeout))
.Batch(batchSize);
var requestQueue = requests.ToQueue();
return(await await SendNextBatchAsync(requestQueue, singleBatchTimeout));
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
return((await WaitForAnyNonFaultedTaskAsync(
ReplicaAddresses.Select(replica =>
Task.Run(async() =>
{
var webRequest = CreateRequest(replica + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(timeout));
return resultTask.Result;
})).ToArray()))?.Result);
}
public async override Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var timer = Stopwatch.StartNew();
Tuple <long, int> valueForLinq;
var webRequests = ReplicaAddresses
.OrderBy(uri =>
{
replicaAverageDelay.TryGetValue(uri, out valueForLinq);
return(valueForLinq.Item1);
})
.ToDictionary(uri => uri, uri => CreateRequest(uri + "?query=" + query));
timeout = new TimeSpan((long)(timeout.Ticks * 1.0 / ReplicaAddresses.Length));
var tasksToAwait = new ConcurrentBag <Task <string> >();
foreach (var pair in webRequests)
{
var tempPair = pair;
Log.InfoFormat("Processing {0}", tempPair.Value.RequestUri);
tasksToAwait.Add(ProcessRequestAsync(tempPair.Value));
var resultTask = await Task.WhenAny(tasksToAwait);
Task.WaitAny(resultTask, Task.Delay(timeout));
if (!resultTask.IsCompleted)
{
continue;
}
if (!resultTask.IsFaulted)
{
var processTime = timer.ElapsedMilliseconds;
Tuple <long, int> currentValue;
replicaAverageDelay.TryGetValue(tempPair.Key, out currentValue);
var newAverDelay = (currentValue.Item1 * currentValue.Item2 + processTime) /
(currentValue.Item2 + 1);
replicaAverageDelay.TryUpdate(tempPair.Key,
Tuple.Create(newAverDelay, currentValue.Item2 + 1), currentValue);
return(resultTask.Result);
}
}
throw new TimeoutException();
}
protected override async Task <string> ProcessRequestAsyncInternal(string query, TimeSpan timeout)
{
if (greylist.Count() == ReplicaAddresses.Length)
{
greylist.Clear();
}
var availableReplicas = ReplicaAddresses.Except(greylist).ToArray();
var singleRequestTimeout = TimeSpan.FromMilliseconds(timeout.TotalMilliseconds / availableReplicas.Length);
var requests = availableReplicas
.OrderBy(replicaStatistics.GetAverageResponseTime)
.Select(addr => CreateRequest($"{addr}?query={query}", timeout)).ToArray();
var requestQueue = new Queue <WebRequest>(requests);
return(await SendNextRequestAsync(requestQueue, singleRequestTimeout));
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var newTimeout = TimeSpan.FromMilliseconds((double)timeout.TotalMilliseconds / ReplicaAddresses.Length);
return((await WaitForAnyNonFaultedTaskAsync(
ReplicaAddresses.Select(replica => Task.Run(async() =>
{
var webRequest = CreateRequest(replica + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(newTimeout));
//Console.WriteLine("1" + resultTask.IsCompleted);
if (resultTask.IsCompleted)
{
return resultTask.Result;
}
//Console.WriteLine("2" + resultTask.IsCompleted);
await Task.WhenAny(resultTask);
//Console.WriteLine("3" + resultTask.IsCompleted);
return resultTask.Result;
})).ToArray()))?.Result);
var bigTask = await WaitForAnyNonFaultedTaskAsync(Task.Run(async() =>
{
foreach (var replica in RandomizeReplicas())
{
var webRequest = CreateRequest(replica + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(newTimeout));
if (!resultTask.IsFaulted && resultTask.IsCompleted)
{
return(resultTask.Result);
}
}
throw new Exception("No Replica Answered");
}));
if (bigTask == null || bigTask.IsFaulted)
{
return(null);
}
return(bigTask.Result);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var queryTasks = ReplicaAddresses
.Select(uri => CreateRequest(uri + "?query=" + query))
.Select(ProcessRequestAsync)
.Concat(new[] { Task.Delay(timeout) })
.ToArray();
var task = await Task.WhenAny(queryTasks);
var result = (task as Task <string>)?.Result;
if (result == null)
{
throw new TimeoutException();
}
return(result);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
foreach (var uri in ReplicaAddresses.OrderBy(x => random.Next()))
{
var webRequest = CreateRequest(uri + "?query=" + query);
var resultTask = ProcessRequestAsync(webRequest);
Console.WriteLine($"Processing {webRequest.RequestUri}");
await Task.WhenAny(resultTask, Task.Delay(GetSoftTimeout(timeout)));
if (resultTask.IsCompleted)
{
return(resultTask.Result);
}
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
try
{
var tasks = ReplicaAddresses.Select(async uri =>
{
var webRequest = CreateRequest(uri + "?query=" + query);
Log.InfoFormat($"Processing {webRequest.RequestUri}");
var resultTask = ProcessRequestAsync(webRequest);
await Task.WhenAny(resultTask, Task.Delay(timeout));
if (!resultTask.IsCompletedSuccessfully)
{
throw new TimeoutException();
}
return(resultTask.Result);
}).ToArray();
while (tasks.Length > 0)
{
var task = await Task.WhenAny(tasks);
if (!task.IsCompletedSuccessfully)
{
tasks = tasks.Except(new[] { task }).ToArray();
}
else
{
return(task.Result);
}
}
throw new TimeoutException();
}
catch (AggregateException e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var shuffledReplicas = ReplicaAddresses.ToArray();
shuffledReplicas.RandomShuffle();
timeout = TimeSpan.FromTicks(timeout.Ticks / shuffledReplicas.Length);
foreach (var task in shuffledReplicas
.Select(uri => CreateRequest(uri + "?query=" + query))
.Select(request => ProcessRequestAsync(request)))
{
if (await Task.WhenAny(task, Task.Delay(timeout)) == task)
{
return(task.Result);
}
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var time = TimeSpan.FromSeconds(timeout.TotalSeconds / ReplicaAddresses.Length);
var shuffledAddresses = ReplicaAddresses.Shuffle();
var webRequests = shuffledAddresses.Select(uri => CreateRequest(uri + "?query=" + query));
foreach (var request in webRequests)
{
Log.InfoFormat("Processing {0}", request.RequestUri);
var task = ProcessRequestAsync(request);
await Task.WhenAny(task, Task.Delay(time));
if (task.IsCompleted && !task.IsFaulted)
{
return(task.Result);
}
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var tasks = ReplicaAddresses
.Select(uri => CreateRequest($"{uri}?query={query}"))
.Select(request =>
{
Log.InfoFormat($"Processing {request.RequestUri}");
return(ProcessRequestAsync(request));
})
.ToArray();
var resultTask = Task.WhenAny(tasks);
await Task.WhenAny(resultTask, Task.Delay(timeout));
if (!resultTask.IsCompleted)
{
throw new TimeoutException();
}
return(resultTask.Result.Result);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var tasks = ReplicaAddresses.Select(async(uri) =>
{
var webRequest = CreateRequest(uri + "?query=" + query);
Console.WriteLine($"Processing {webRequest.RequestUri}");
return(await ProcessRequestAsync(webRequest));
});
var timeoutTask = Task.Delay(timeout);
tasks.Append(timeoutTask);
var resultTask = await Task.WhenAny(tasks);
if (!resultTask.IsCompleted)
{
throw new TimeoutException();
}
return(resultTask.Result);
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
timeout = TimeSpan.FromSeconds(timeout.TotalSeconds / ReplicaAddresses.Length);
var orderedAddresses = ReplicaAddresses.OrderBy(addr => requestStatistics[addr].GetValue()).ToArray();
orderedAddresses.ForEach(uri => stopwatches[uri] = new Stopwatch());
var tasksPool = new Dictionary <string, Task <string> >();
foreach (var uri in orderedAddresses)
{
var request = CreateRequest(uri + "?query=" + query);
Log.InfoFormat("Processing {0}", request.RequestUri);
tasksPool[uri] = ProcessRequestAsync(request);
var task = Task.WhenAny(tasksPool.Values);
await Task.WhenAny(task, Task.Delay(timeout));
if (task.IsCompleted && !task.IsFaulted)
{
stopwatches.Values.ForEach(timer => timer.Stop());
var completed = tasksPool.First(pair => pair.Value.IsCompleted).Key;
requestStatistics[completed].Update(stopwatches[completed].ElapsedMilliseconds);
stopwatches.Values.ForEach(timer => timer.Reset());
return(task.Result.Result);
}
stopwatches[uri].Stop();
requestStatistics[uri].Update(stopwatches[uri].ElapsedMilliseconds);
stopwatches[uri].Start();
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var shuffledReplicas = ReplicaAddresses.ToArray();
shuffledReplicas.RandomShuffle();
timeout = TimeSpan.FromTicks(timeout.Ticks / shuffledReplicas.Length);
var queries = new List <RequestDescriptor>();
foreach (var uri in shuffledReplicas)
{
var guid = Guid.NewGuid();
var request = CreateRequest(uri + "?query=" + query + "&guid=" + guid);
var task = ProcessRequestAsync(request);
queries.Add(new RequestDescriptor(uri, guid, task));
var finishedTask = await Task.WhenAny(queries
.Select(d => d.Task)
.Concat(new[] { Task.Delay(timeout) }));
if (!(finishedTask is Task <string>))
{
continue;
}
foreach (var _ in queries
.Where(d => d.Task != finishedTask)
.Select(d => CreateRequest(d.Uri + "?abort=" + "&guid=" + d.Guid))
.Select(r => ProcessRequestAsync(r)))
{
;
}
return((finishedTask as Task <string>).Result);
}
throw new TimeoutException();
}
public override async Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
ReplicaAddresses.Shuffle(rand);
var timeoutOneTask = new TimeSpan(timeout.Ticks / ReplicaAddresses.Length);
var timerForAllTasks = Task.Delay(timeout);
var resultTasks = new List <Task> {
timerForAllTasks
};
foreach (var uri in ReplicaAddresses)
{
var timer = Task.Delay(timeoutOneTask);
var webRequest = CreateRequest(uri + "?query=" + query);
Log.InfoFormat("Processing {0}", webRequest.RequestUri);
resultTasks.Add(ProcessRequestAsync(webRequest));
var taskWithTimer = resultTasks.Concat(new[] { timer }).ToList();
var completed = await Task.WhenAny(taskWithTimer);
if (timerForAllTasks.IsCompleted)
{
throw new TimeoutException();
}
if (timer.IsCompleted)
{
continue;
}
if (!completed.IsFaulted)
{
return(((Task <string>)completed).Result);
}
resultTasks.Remove(completed);
}
throw new TimeoutException();
}
public async override Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var responseTasks = new Dictionary <WebRequest, Task <string> >();
var globalTimer = Stopwatch.StartNew();
foreach (var webRequest in ReplicaAddresses.Select(uri => CreateRequest(uri + "?query=" + query)))
{
Log.InfoFormat($"Processing {webRequest.RequestUri} {DateTime.Now.TimeOfDay}");
var interRequestsDelay = new TimeSpan((timeout - globalTimer.Elapsed).Ticks / (ReplicaAddresses.Length - responseTasks.Count));
if (interRequestsDelay < TimeSpan.Zero)
{
throw new TimeoutException();
}
responseTasks[webRequest] = ProcessRequestAsync(webRequest);
await Task.WhenAny(responseTasks.Values.Concat(new[] { Task.Delay(interRequestsDelay) }));
var responseTask = responseTasks.Values.FirstOrDefault(t => t.IsCompleted);
if (responseTask == null)
{
continue;
}
foreach (var webRequestToAbort in responseTasks.Where(t => !t.Value.IsCompleted).Select(t => t.Key))
{
webRequestToAbort.Abort();
Log.InfoFormat("WebRequest to {0} was aborted", webRequestToAbort.RequestUri);
}
return(responseTask.Result);
}
throw new TimeoutException();
}
public async override Task <string> ProcessRequestAsync(string query, TimeSpan timeout)
{
var webRequests = ReplicaAddresses
.Select(uri => CreateRequest(uri + "?query=" + query))
.ToArray();
foreach (var request in webRequests)
{
Log.InfoFormat("Processing {0}", request);
}
var requestTasks = webRequests
.Select(async request => await ProcessRequestAsync(request))
.ToList();
while (requestTasks.Count > 0)
{
var resultTask = await Task.WhenAny(requestTasks);
await Task.WhenAny(resultTask, Task.Delay(timeout));
if (!resultTask.IsCompleted)
{
throw new TimeoutException();
}
if (!resultTask.IsFaulted)
{
return(resultTask.Result);
}
requestTasks.Remove(resultTask);
}
throw new TimeoutException();
}
