public void Operate(string testId, SessionStopInfo sessionStopInfo, TaskListener <TestResults> listener)
{
if (sessionStopInfo == null)
{
TestResults testResults = new TestResults();
testResults.Status = TestResultsStatus.NotOpened;
listener.OnComplete(testResults);
return;
}
TaskListener <TestResults> taskListener = new TaskListener <TestResults>(
(testResults) =>
{
Logger.Log(TraceLevel.Notice, testId, Stage.Close, new { testResults.Status });
testResults.IsNew = sessionStopInfo.RunningSession.IsNewSession;
testResults.Url = sessionStopInfo.RunningSession.Url;
Logger.Verbose(testResults.ToString());
testResults.ServerConnector = ServerConnector;
listener.OnComplete(testResults);
},
(ex) =>
{
listener.OnFail(new EyesException("Failed closing test", ex));
});
try
{
Logger.Log(TraceLevel.Notice, testId, Stage.Close, new { sessionStopInfo });
ServerConnector.EndSession(taskListener, sessionStopInfo);
}
catch (Exception e)
{
listener.OnFail(e);
}
}
private void UploadData_(TaskListener <string> listener, byte[] bytes, string contentType, string mediaType,
string[] testIds)
{
RenderingInfo renderingInfo = GetRenderingInfo();
string targetUrl = renderingInfo?.ResultsUrl?.AbsoluteUri;
if (targetUrl == null)
{
listener.OnComplete(null);
return;
}
Guid guid = Guid.NewGuid();
targetUrl = targetUrl.Replace("__random__", guid.ToString());
Logger.Log(TraceLevel.Info, testIds, Stage.General, StageType.UploadStart, new { mediaType, targetUrl });
HttpRequestMessage request = CreateHttpRequestMessageForUpload_(targetUrl, bytes, contentType, mediaType);
httpClient_.SendAsyncRequest(new TaskListener <HttpResponseMessage>(
response =>
{
if (response == null)
{
throw new NullReferenceException("response is null");
}
listener.OnComplete(targetUrl);
},
ex => listener.OnFail(ex)),
request, Logger, new BackoffProvider(2), TimeSpan.FromMinutes(2));
}
public void TryUploadImage(string testId, MatchWindowData data, TaskListener taskListener)
{
AppOutput appOutput = data.AppOutput;
if (appOutput.ScreenshotUrl != null)
{
taskListener.OnComplete();
return;
}
// Getting the screenshot bytes
TaskListener <string> uploadListener = new TaskListener <string>(
(url) =>
{
if (url == null)
{
Logger.Verbose("Got null url from upload. Test id: {0}", testId);
appOutput.ScreenshotUrl = null;
taskListener.OnFail(new EyesException("Failed uploading image"));
return;
}
Logger.Log(TraceLevel.Info, testId, Stage.Check, StageType.UploadComplete, new { url });
appOutput.ScreenshotUrl = url;
appOutput.ClearScreenshotBytes();
taskListener.OnComplete();
},
(ex) =>
{
appOutput.ScreenshotUrl = null;
taskListener.OnFail(new EyesException("Failed uploading image", ex));
}
);
try
{
Logger.Log(TraceLevel.Info, testId, Stage.Check, StageType.UploadStart,
new { dataLength = appOutput.ScreenshotBytes.Length });
ServerConnector.UploadImage(uploadListener, appOutput.ScreenshotBytes, testId);
}
catch (Exception ex)
{
taskListener.OnFail(ex);
}
}
protected virtual void SendUFGAsyncRequest_ <T>(TaskListener <T> taskListener, HttpRequestMessage request) where T : class
{
httpClient_.SendAsyncRequest(new TaskListener <HttpResponseMessage>(
response =>
{
if (response == null)
{
throw new NullReferenceException("response is null");
}
taskListener.OnComplete(response.DeserializeBody <T>(true));
},
ex => taskListener.OnFail(ex)), request, Logger, new BackoffProvider());
}
protected virtual void StartSessionInternal(TaskListener <RunningSession> taskListener, SessionStartInfo startInfo)
{
ArgumentGuard.NotNull(startInfo, nameof(startInfo));
var body = new
{
StartInfo = startInfo
};
try
{
EnsureHttpClient_();
httpClient_.PostJson(
new TaskListener <HttpResponseMessage>(
response =>
{
if (response == null)
{
throw new NullReferenceException("response is null");
}
// response.DeserializeBody disposes the response object's stream,
// rendering all of its properties unusable, including StatusCode.
HttpStatusCode responseStatusCode = response.StatusCode;
RunningSession runningSession;
if (responseStatusCode == HttpStatusCode.ServiceUnavailable)
{
runningSession = new RunningSession();
runningSession.ConcurrencyFull = true;
}
else
{
runningSession = response.DeserializeBody <RunningSession>(
true, serializer_, HttpStatusCode.OK, HttpStatusCode.Created);
if (runningSession.isNewSession_ == null)
{
runningSession.isNewSession_ = responseStatusCode == HttpStatusCode.Created;
}
runningSession.ConcurrencyFull = false;
}
taskListener.OnComplete(runningSession);
}, ex => taskListener.OnFail(ex))
, "api/sessions/running", body);
}
catch (Exception ex)
{
throw new EyesException($"StartSession failed: {ex.Message}", ex);
}
}
protected virtual void EndSessionInternal(TaskListener <TestResults> taskListener, SessionStopInfo sessionStopInfo)
{
ArgumentGuard.NotNull(sessionStopInfo, nameof(sessionStopInfo));
ArgumentGuard.NotNull(sessionStopInfo.RunningSession, nameof(sessionStopInfo.RunningSession));
httpClient_.DeleteJson(new TaskListener <HttpResponseMessage>(
response =>
{
if (response == null)
{
throw new NullReferenceException("response is null");
}
taskListener.OnComplete(response.DeserializeBody <TestResults>(true));
},
ex => taskListener.OnFail(ex)
), $"api/sessions/running/{sessionStopInfo.RunningSession.Id}", sessionStopInfo);
}
private void OnComplete_(SessionStartInfo sessionStartInfo, TaskListener <RunningSession> listener,
RunningSession runningSession, Stopwatch stopwatch, string testId)
{
if (runningSession.ConcurrencyFull)
{
isServerConcurrencyLimitReached_ = true;
Logger.Log(TraceLevel.Warn, testId, Stage.Open, StageType.Retry,
new { message = "Failed starting test, concurrency is fully used. Trying again." });
OnFail_(stopwatch, sessionStartInfo, listener, testId);
return;
}
isServerConcurrencyLimitReached_ = false;
Logger.Log(TraceLevel.Notice, testId, Stage.Open, StageType.Complete,
new { message = $"Server session ID is {runningSession.Id}" });
//Logger.SessionId(runningSession.SessionId);
listener.OnComplete(runningSession);
}
protected virtual void MatchWindowImpl_(TaskListener <MatchResult> listener, MatchWindowData data, string[] testIds)
{
string url = string.Format("api/sessions/running/{0}", data.RunningSession.Id);
Logger.Log(TraceLevel.Notice, testIds, Stage.Check, StageType.MatchStart);
httpClient_.PostJson(new TaskListener <HttpResponseMessage>(
response =>
{
Logger.Log(TraceLevel.Notice, testIds, Stage.Check, StageType.MatchComplete,
new { response?.StatusCode });
if (response == null)
{
throw new NullReferenceException("response is null");
}
MatchResult matchResult = response.DeserializeBody <MatchResult>(true);
Logger.Log(TraceLevel.Info, testIds, Stage.Check, StageType.MatchComplete, new { matchResult });
listener.OnComplete(matchResult);
},
e => listener.OnFail(e)
), url, data);
}
public virtual void GetJobInfo(TaskListener <IList <JobInfo> > listener, IList <IRenderRequest> renderRequests)
{
ArgumentGuard.NotNull(renderRequests, nameof(renderRequests));
string[] testIds = renderRequests.Select(bi => bi.TestId).ToArray();
Logger.Log(TraceLevel.Notice, testIds, Stage.Open, StageType.JobInfo, new { renderRequests });
try
{
HttpRequestMessage request = CreateUfgHttpWebRequest_("job-info", content: renderRequests);
Logger.Log(TraceLevel.Info, testIds, Stage.Open, StageType.RequestSent, new { request.RequestUri });
httpClient_.SendAsyncRequest(new TaskListener <HttpResponseMessage>(
response =>
{
JObject[] jobInfosUnparsed = response.DeserializeBody <JObject[]>(true);
List <JobInfo> jobInfos = new List <JobInfo>();
foreach (JObject jobInfoUnparsed in jobInfosUnparsed)
{
JobInfo jobInfo = new JobInfo
{
Renderer = jobInfoUnparsed.Value <string>("renderer"),
EyesEnvironment = jobInfoUnparsed.Value <object>("eyesEnvironment")
};
jobInfos.Add(jobInfo);
}
Logger.Log(TraceLevel.Info, testIds, Stage.Open, StageType.RequestCompleted, new { request.RequestUri });
listener.OnComplete(jobInfos);
},
ex => listener.OnFail(ex)
), request, Logger, new BackoffProvider());
}
catch (Exception e)
{
CommonUtils.LogExceptionStackTrace(Logger, Stage.Open, StageType.JobInfo, e, testIds);
listener.OnFail(e);
}
}
