public void Operate(string testId, SessionStartInfo sessionStartInfo, TaskListener <RunningSession> listener) { Logger.Log(TraceLevel.Notice, testId, Stage.Open, new { sessionStartInfo.AgentSessionId }); Stopwatch stopwatch = Stopwatch.StartNew(); TaskListener <RunningSession> taskListener = new TaskListener <RunningSession>( (runningSession) => OnComplete_(sessionStartInfo, listener, runningSession, stopwatch, testId), (ex) => { var webEx = CommonUtils.GetInnerException <WebException>(ex); if (webEx != null && webEx.Status != WebExceptionStatus.Success) { CommonUtils.LogExceptionStackTrace(Logger, Stage.Open, ex, new { webExceptionStatus = webEx.Status }, testId); listener.OnFail(ex.InnerException); return; } OnFail_(stopwatch, sessionStartInfo, listener, testId); } ); try { ServerConnector.StartSession(taskListener, sessionStartInfo); } catch (Exception e) { listener.OnFail(e); } }
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 virtual void PostDomCapture(TaskListener <string> listener, string domJson, params string[] testIds) { Logger.Log(TraceLevel.Info, testIds, Stage.Check, StageType.UploadStart); try { byte[] binData = Encoding.UTF8.GetBytes(domJson); Logger.Log(TraceLevel.Info, testIds, Stage.Check, StageType.UploadResource, new { UncompressedDataSize = binData.Length }); using (MemoryStream compressedStream = new MemoryStream()) { using (var zipStream = new GZipStream(compressedStream, CompressionMode.Compress)) { zipStream.Write(binData, 0, binData.Length); } binData = compressedStream.ToArray(); } Logger.Log(TraceLevel.Notice, testIds, Stage.Check, StageType.UploadResource, new { CompressedDataSize = binData.Length }); UploadData_(listener, binData, "application/octet-stream", "application/json", testIds); } catch (Exception ex) { CommonUtils.LogExceptionStackTrace(Logger, Stage.Check, StageType.UploadResource, ex, testIds); listener.OnFail(new EyesException($"PostDomSnapshot failed: {ex.Message}", ex)); } }
private void OnFail_(Stopwatch stopwatch, SessionStartInfo sessionStartInfo, TaskListener <RunningSession> listener, string testId) { TimeSpan sleepDuration = TimeSpan.FromSeconds(2); if (stopwatch.Elapsed > TIME_TO_WAIT_FOR_OPEN) { isServerConcurrencyLimitReached_ = false; listener.OnFail(new EyesException("Timeout in start session")); return; } try { Thread.Sleep(sleepDuration); if (stopwatch.Elapsed.TotalSeconds >= 30) { sleepDuration = TimeSpan.FromSeconds(10); } else if (stopwatch.Elapsed.TotalSeconds >= 10) { sleepDuration = TimeSpan.FromSeconds(5); } Logger.Verbose("Trying startSession again"); ServerConnector.StartSession( new TaskListener <RunningSession>( (runningSession) => OnComplete_(sessionStartInfo, listener, runningSession, stopwatch, testId), (ex) => { var socketEx = CommonUtils.GetInnerException <SocketException>(ex); if (socketEx != null && socketEx.SocketErrorCode == SocketError.ConnectionRefused) { listener.OnFail(ex.InnerException); return; } OnFail_(stopwatch, sessionStartInfo, listener, testId); } ), sessionStartInfo); } catch (Exception e) { CommonUtils.LogExceptionStackTrace(Logger, Stage.Open, StageType.Retry, e, testId); listener.OnFail(e); } }
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()); }
public void MatchWindow(TaskListener <MatchResult> listener, MatchWindowData data, params string[] testIds) { ArgumentGuard.NotNull(data, nameof(data)); if (data.AppOutput.ScreenshotBytes != null) { UploadImage(new TaskListener <string>( returnedUrl => { Logger.Log(TraceLevel.Notice, testIds, Stage.General, StageType.UploadComplete, new { returnedUrl }); if (returnedUrl == null) { listener.OnFail(new EyesException($"{nameof(MatchWindow)} failed: could not upload image to storage service.")); return; } try { data.AppOutput.ScreenshotUrl = returnedUrl; MatchWindowImpl_(listener, data, testIds); } catch (Exception ex) { throw new EyesException($"{nameof(MatchWindow)} failed: {ex.Message}", ex); } }, ex => listener.OnFail(ex) ), data.AppOutput.ScreenshotBytes, testIds); } else if (data.AppOutput.ScreenshotUrl != null) { MatchWindowImpl_(listener, data, testIds); } else { throw new EyesException("Failed to upload image."); } }
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); } }
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); }
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); }