public PutFuture(RGridResource resource, RunningRender runningRender, IEyesConnector eyesConnector, Logger logger)
{
resource_ = resource;
runningRender_ = runningRender;
eyesConnector_ = eyesConnector;
logger_ = logger;
}
private void SampleRenderingStatus_(Dictionary <RunningRender, RenderRequest> runningRenders, List <string> ids, List <RenderStatusResults> renderStatusResultsList)
{
logger_.Verbose("enter - renderStatusResultsList size: {0}", renderStatusResultsList.Count);
for (int i = renderStatusResultsList.Count - 1; i >= 0; i--)
{
RenderStatusResults renderStatusResults = renderStatusResultsList[i];
if (renderStatusResults == null)
{
continue;
}
RenderStatus renderStatus = renderStatusResults.Status;
bool isRenderedStatus = renderStatus == RenderStatus.Rendered;
bool isErrorStatus = renderStatus == RenderStatus.Error;
logger_.Verbose("renderStatusResults - {0}", renderStatusResults);
if (isRenderedStatus || isErrorStatus)
{
string removedId = ids[i];
ids.RemoveAt(i);
foreach (KeyValuePair <RunningRender, RenderRequest> kvp in runningRenders)
{
RunningRender renderedRender = kvp.Key;
RenderRequest renderRequest = kvp.Value;
if (renderedRender.RenderId.Equals(removedId, StringComparison.OrdinalIgnoreCase))
{
VisualGridTask task = runningRenders[renderedRender].Task;
for (int k = openTasks_.Count - 1; k >= 0; k--)
{
VisualGridTask openTask = openTasks_[k];
if (openTask.RunningTest == task.RunningTest)
{
if (isRenderedStatus)
{
logger_.Verbose("setting openTask {0} render result: {1} to url {2}", openTask, renderStatusResults, result_.Url);
openTask.SetRenderResult(renderStatusResults);
}
else
{
logger_.Verbose("setting openTask {0} render error: {1} to url {2}", openTask, removedId, result_.Url);
openTask.SetRenderError(removedId, renderStatusResults.Error, renderRequest);
}
openTasks_.RemoveAt(k);
}
}
logger_.Verbose("setting task {0} render result: {1} to url {2}", task, renderStatusResults, result_.Url);
task.SetRenderResult(renderStatusResults);
break;
}
}
}
}
logger_.Verbose("exit");
}
private Dictionary <RunningRender, RenderRequest> MapRequestToRunningRender_(List <RunningRender> runningRenders, RenderRequest[] requests)
{
Dictionary <RunningRender, RenderRequest> mapping = new Dictionary <RunningRender, RenderRequest>();
if (runningRenders != null && requests != null && runningRenders.Count >= requests.Length)
{
for (int i = 0; i < requests.Length; i++)
{
RenderRequest request = requests[i];
RunningRender runningRender = runningRenders[i];
mapping.Add(runningRender, request);
}
}
return(mapping);
}
internal void CreatePutFutures_(List <PutFuture> allPuts, RunningRender runningRender, IDictionary <string, RGridResource> resources)
{
List <Uri> needMoreResources = runningRender.NeedMoreResources;
foreach (Uri url in needMoreResources)
{
string urlStr = SanitizeUrl_(url.OriginalString);
if (putResourceCache_.TryGetValue(urlStr, out PutFuture putFuture))
{
if (!allPuts.Contains(putFuture))
{
allPuts.Add(putFuture);
}
continue;
}
RGridResource resource;
//logger_.Verbose("trying to get url from map - {0}", url);
if (!fetchedCacheMap_.TryGetValue(urlStr, out ResourceFuture resourceFuture) || resourceFuture == null)
{
logger_.Verbose("fetchedCacheMap.get(url) == null - " + url);
logger_.Log("Resource put requested but never downloaded (maybe a Frame)");
resources.TryGetValue(urlStr, out resource);
}
else
{
try
{
Task <RGridResource> resourceTask = resourceFuture.Get(TimeSpan.FromSeconds(60));
resource = resourceTask.Result;
}
catch (Exception e)
{
logger_.Log("Error (6): " + e);
continue;
}
}
logger_.Verbose("resource({0}) hash : {1}", resource.Url, resource.Sha256);
PutFuture future = connector_.RenderPutResource(runningRender, resource);
if (resource.ContentType != RGridDom.ContentType)
{
putResourceCache_.TryAdd(urlStr, future);
}
allPuts.Add(future);
}
}
private void SendMissingResources_(List <RunningRender> runningRenders, RGridDom dom, IDictionary <string, RGridResource> resources, bool isNeedMoreDom)
{
logger_.Verbose("enter - sending {0} missing resources. need more dom: {1}", resources.Count, isNeedMoreDom);
List <PutFuture> allPuts = new List <PutFuture>();
if (isNeedMoreDom)
{
RunningRender runningRender = runningRenders[0];
PutFuture future = null;
try
{
future = connector_.RenderPutResource(runningRender, dom.AsResource());
}
catch (JsonException e)
{
logger_.Log("Error (4): " + e);
}
logger_.Verbose("locking putResourceCache");
lock (putResourceCache_)
{
allPuts.Add(future);
}
logger_.Verbose("releasing putResourceCache");
}
logger_.Verbose("creating PutFutures for {0} runningRenders", runningRenders.Count);
foreach (RunningRender runningRender in runningRenders)
{
CreatePutFutures_(allPuts, runningRender, resources);
}
logger_.Verbose("calling future.get on {0} PutFutures", allPuts.Count);
foreach (PutFuture future in allPuts)
{
logger_.Verbose("calling future.get on {0}", future);
try
{
future.Get(TimeSpan.FromSeconds(120));
}
catch (Exception e)
{
logger_.Log("Error (5): " + e);
}
}
logger_.Verbose("exit");
}
public PutFuture(Task <WebResponse> putFuture, RGridResource resource, RunningRender runningRender, IEyesConnector eyesConnector, Logger logger)
: this(resource, runningRender, eyesConnector, logger)
{
putFuture_ = putFuture;
}
private void ForcePutAllResources_(IDictionary <string, RGridResource> resources, RunningRender runningRender)
{
/*
* RGridResource resource;
* List<PutFuture> allPuts = new List<PutFuture>();
* foreach (Uri url in resources.Keys)
* {
* try
* {
* logger_.Verbose("trying to get url from map - {0}", url);
* if (!fetchedCacheMap_.TryGetValue(url, out ResourceFuture resourceFuture))
* {
* logger_.Verbose("fetchedCacheMap.get(url) == null trying dom");
* if (url.Equals(dom_.Url))
* {
* resource = dom_.AsResource();
* }
* else
* {
* logger_.Log("Resource not found Exiting...");
* return;
* }
* }
* else
* {
* resource = resourceFuture.Get();
* PutFuture future = connector_.RenderPutResource(runningRender, resource);
* logger_.Verbose("locking putResourceCache");
* lock (putResourceCache_)
* {
* putResourceCache_.Add(dom_.Url, future);
* allPuts.Add(future);
* }
* }
* }
* catch (Exception e)
* {
* logger_.Log("Error: " + e);
* }
* }
* foreach (PutFuture put in allPuts)
* {
* put.Get();
* }
*/
}
private void PollRenderingStatus_(Dictionary <RunningRender, RenderRequest> runningRenders)
{
logger_.Verbose("enter");
List <string> ids = GetRenderIds_(runningRenders.Keys);
Stopwatch stopwatch = Stopwatch.StartNew();
do
{
List <RenderStatusResults> renderStatusResultsList = null;
try
{
renderStatusResultsList = connector_.RenderStatusById(ids.ToArray());
}
catch (Exception e)
{
logger_.Log("Error (3): " + e);
continue;
}
if (renderStatusResultsList == null || renderStatusResultsList.Count == 0)
{
logger_.Verbose("No reason to sample. (ids.Count: {0})", ids.Count);
Thread.Sleep(500);
continue;
}
if (renderStatusResultsList[0] == null)
{
logger_.Verbose("First element is null. Total number of elements: {0}. Continuing.", renderStatusResultsList.Count);
Thread.Sleep(500);
continue;
}
SampleRenderingStatus_(runningRenders, ids, renderStatusResultsList);
if (ids.Count > 0)
{
Thread.Sleep(1500);
}
logger_.Verbose("ids.Count: {0} ; runtime: {1}", ids.Count, stopwatch.Elapsed);
} while (ids.Count > 0 && stopwatch.Elapsed < pollTimeout_);
foreach (string id in ids)
{
foreach (KeyValuePair <RunningRender, RenderRequest> kvp in runningRenders)
{
RunningRender renderedRender = kvp.Key;
RenderRequest renderRequest = kvp.Value;
if (renderedRender.RenderId.Equals(id, StringComparison.OrdinalIgnoreCase))
{
VisualGridTask task = runningRenders[renderedRender].Task;
logger_.Verbose("removing failed render id: {0}", id);
task.SetRenderError(id, "too long rendering(rendering exceeded 150 sec)", renderRequest);
break;
}
}
}
ICheckSettingsInternal rcInternal = (ICheckSettingsInternal)settings_;
logger_.Verbose("marking task as complete: {0}", rcInternal.GetName());
IsTaskComplete = true;
NotifySuccessAllListeners_();
logger_.Verbose("exit");
}
public async Task <RenderStatusResults> CallAsync()
{
logger_.Verbose("enter");
List <RunningRender> runningRenders = null;
isTaskStarted_ = true;
RenderRequest[] requests = new RenderRequest[0];
try
{
logger_.Verbose("step 1");
AddRenderingTaskToOpenTasks_();
bool isSecondRequestAlreadyHappened = false;
//Parse to Map
logger_.Verbose("step 2");
//Build RenderRequests
requests = PrepareDataForRG_(result_);
logger_.Verbose("step 3");
bool stillRunning = true;
bool isForcePutAlreadyDone = false;
Stopwatch timeoutTimer = Stopwatch.StartNew();
do
{
try
{
runningRenders = await connector_.RenderAsync(requests);
}
catch (Exception e)
{
var settings = JsonUtils.CreateSerializerSettings();
string j = JsonConvert.SerializeObject(requests, settings);
string responseBodyStr = string.Empty;
if (e is WebException we && we.Response != null)
{
Stream stream = we.Response.GetResponseStream();
byte[] responseBodyBytes = CommonUtils.ReadToEnd(stream);
responseBodyStr = Encoding.UTF8.GetString(responseBodyBytes);
}
logger_.Verbose("/render throws exception. sleeping for 1.5s");
Thread.Sleep(1500);
if (responseBodyStr.Contains("Second request, yet still some resources were not PUT in renderId"))
{
if (isSecondRequestAlreadyHappened)
{
logger_.Verbose("Second request already happened");
}
isSecondRequestAlreadyHappened = true;
}
logger_.Verbose("Error (1): " + e);
logger_.Verbose("Error Response Body: " + responseBodyStr);
}
logger_.Verbose("step 4.1");
if (runningRenders == null)
{
logger_.Verbose("ERROR - runningRenders is null.");
SetRenderErrorToTasks_(requests);
continue;
}
for (int i = 0; i < requests.Length; i++)
{
RenderRequest request = requests[i];
request.RenderId = runningRenders[i].RenderId;
}
logger_.Verbose("step 4.2");
RunningRender runningRender = runningRenders[0];
RenderStatus worstStatus = runningRender.RenderStatus;
worstStatus = CalcWorstStatus_(runningRenders, worstStatus);
bool isNeedMoreDom = runningRender.NeedMoreDom;
if (isForcePutNeeded_ && !isForcePutAlreadyDone)
{
ForcePutAllResources_(requests[0].Resources, runningRender);
isForcePutAlreadyDone = true;
}
logger_.Verbose("step 4.3");
stillRunning = (worstStatus == RenderStatus.NeedMoreResources || isNeedMoreDom) && (timeoutTimer.Elapsed.TotalSeconds < FETCH_TIMEOUT_SECONDS);
if (stillRunning)
{
SendMissingResources_(runningRenders, requests[0].Dom, requests[0].Resources, isNeedMoreDom);
}
logger_.Verbose("step 4.4");
} while (stillRunning);
}
catch (Exception e)
{
logger_.Log("Error: " + e);
SetRenderErrorToTasks_(requests);
}
Dictionary <RunningRender, RenderRequest> mapping = MapRequestToRunningRender_(runningRenders, requests);
logger_.Verbose("step 5");
try
{
PollRenderingStatus_(mapping);
}
catch (Exception e)
{
isTaskInException = true; // FOR DEBUGGING
logger_.Log("Error (2): " + e);
foreach (VisualGridTask visualGridTask in taskList_)
{
visualGridTask.SetExceptionAndAbort(e);
}
}
IsTaskComplete = true;
logger_.Verbose("exit");
return(null);
}
