private async Task <BuildContentOutput> DoBuildContentForBuildRequestAsync(BuildRequest buildRequest) { Message message = buildRequest.SharedObject.GetValue <Message>(Constants.BuildMessage); // add message priority into AmbientContext SetMessagePriorityInAmbientContext(message); TraceEx.TraceInformation( string.Format( "Build content for request Action: {0}, EntityIdentifier: {1}, Message: {2}", buildRequest.ActionName, buildRequest.EntityIdentifier, Utility.ToJsonString(message))); string pipelineName = BuildActionMapper.GetPipelineName(buildRequest.ActionName); if (string.IsNullOrEmpty(pipelineName)) { string errorMessage = LogMessage.FormatMessage(LogCode.PipelineForActionNotFound, buildRequest.ActionName); TraceEx.TraceError(errorMessage); throw new ArgumentException(errorMessage); } BuildEngine engine; BuildContext context; using (new PerformanceScopeWrapper( "Setup Context", PerformanceCategory.Pipeline)) { string reportPipelineName = GetReportPipelineName(buildRequest.ActionName, message.MessageType); engine = BuildEngineFactory.CreateEngineByPipelineName(reportPipelineName); context = engine.Context; context.XmlContext.AddVariable(Constants.ContextData.PipelineName, pipelineName); await SetupContextAsync(context, buildRequest); context.SetSharedObject(Constants.ContextData.PipelineStartTime, DateTime.UtcNow); } PipelineResult result = PipelineResult.Break; using (new PerformanceScopeWrapper( string.Format("Setup Pipeline: {0}", buildRequest.ActionName), PerformanceCategory.Pipeline)) { engine.Pipeline.Setup(context); } XmlDocument document = new XmlDocument(); result = await engine.Pipeline.ApplyAsync(document, context); return(new BuildContentOutput { BuildContentResult = result == PipelineResult.NeedRerun ? BuildContentResult.NeedRerun : BuildContentResult.Succeeded, Outputs = context.Outputs }); }
private EngineExecutor() { try { // environment variable to be used in the pipeline transform component Environment.SetEnvironmentVariable(Constants.BuildSetupFilePath, CommonServiceConfiguration.BuildSetupFilesUrl); Environment.SetEnvironmentVariable(Constants.ExecutableDir, CommonServiceConfiguration.ExecutableDir); } catch (Exception e) { TraceEx.TraceError(LogMessage.FormatMessage(LogCode.EngineExecutorInitError, e.Message)); throw; } }
public static async void RunTaskSilentlyNoWait(Task task, [CallerMemberName] string taskDescription = null) { Guard.ArgumentNotNull(task, nameof(task)); try { await task; TraceEx.TraceInformation($"{taskDescription} succeeded."); } catch (Exception ex) { TraceEx.TraceError($"{taskDescription} failed: {ex}"); } }
public static async Task <bool> CompleteTaskWithinTimeOutAsync(Task task, int timeoutInSeconds, string taskDescription, Func <Exception> exceptionGeneratorOnTimeout) { Guard.ArgumentNotNull(task, nameof(task)); Guard.ArgumentNotNull(exceptionGeneratorOnTimeout, nameof(exceptionGeneratorOnTimeout)); if (timeoutInSeconds <= 0 || await RunTaskWithTimeoutAsync(task, TimeSpan.FromSeconds(timeoutInSeconds), taskDescription)) { await task; return(true); } TraceEx.TraceError($"{taskDescription} timeout in {timeoutInSeconds} seconds."); throw exceptionGeneratorOnTimeout(); }
// The same behavior as "RunTaskSilentlyNoWait". // but it is bad because it returns Task, // and the caller has chance to wait "RunTaskSilentlyNoWaitBad" to complete. public static async Task RunTaskSilentlyNoWaitBad(Task task, string taskDescription = null) { Guard.ArgumentNotNull(task, nameof(task)); try { Console.WriteLine(task.Status + ": RunTaskSilentlyNoWait1"); await task; Console.WriteLine(task.Status + " : RunTaskSilentlyNoWait1"); } catch (Exception ex) { TraceEx.TraceError(taskDescription != null ? $"{taskDescription} failed: {ex}" : $"Running task failed: {ex}"); } }
// The same as RunTaskSilentlyNoWait. public static async void RunTaskSilentlyNoWaitUsingFunc(Func <Task> task, string taskDescription = null) { Guard.ArgumentNotNull(task, nameof(task)); try { Task t = task(); Console.WriteLine(t.Status); await t; Console.WriteLine(t.Status); } catch (Exception ex) { TraceEx.TraceError(taskDescription != null ? $"{taskDescription} failed: {ex}" : $"Running task failed: {ex}"); } }
/// <summary> /// Execute exe /// </summary> /// <param name="executionInfo">execution info</param> /// <param name="stdoutWriter">stdout stream writer, null to ignore stdout</param> /// <param name="stderrWriter">stderr stream writer, null to ignore stderr</param> /// <param name="timeoutInMilliseconds">timeout in milliseconds, -1 to wait infinitely</param> /// <returns>return value of the exe</returns> public static int ExecuteExe(ProcessExecutionInfo executionInfo, StreamWriter stdoutWriter, StreamWriter stderrWriter, int timeoutInMilliseconds = Timeout.Infinite) { Guard.ArgumentNotNull(executionInfo, nameof(executionInfo)); Guard.ArgumentNotNullOrEmpty(executionInfo.ExeFilePath, $"{nameof(executionInfo)}.{nameof(executionInfo.ExeFilePath)}"); if (timeoutInMilliseconds < 0 && timeoutInMilliseconds != Timeout.Infinite) { throw new ArgumentOutOfRangeException(nameof(timeoutInMilliseconds), $"{nameof(timeoutInMilliseconds)} must be equal to or greater than 0, or equal to {Timeout.Infinite}."); } using (Process buildProcess = new Process()) { buildProcess.StartInfo.FileName = Environment.ExpandEnvironmentVariables(executionInfo.ExeFilePath); buildProcess.StartInfo.UseShellExecute = false; buildProcess.StartInfo.CreateNoWindow = true; buildProcess.StartInfo.Arguments = executionInfo.Arguments; buildProcess.StartInfo.WorkingDirectory = executionInfo.WorkingDirectory == null ? null : Environment.ExpandEnvironmentVariables(executionInfo.WorkingDirectory); // set TEMP/TMP variables buildProcess.StartInfo.EnvironmentVariables["TEMP"] = Environment.GetEnvironmentVariable("TEMP"); buildProcess.StartInfo.EnvironmentVariables["TMP"] = Environment.GetEnvironmentVariable("TMP"); buildProcess.StartInfo.EnvironmentVariables["PATH"] = Environment.GetEnvironmentVariable("PATH"); buildProcess.StartInfo.RedirectStandardOutput = true; buildProcess.StartInfo.StandardOutputEncoding = Encoding.UTF8; buildProcess.StartInfo.RedirectStandardError = true; buildProcess.StartInfo.StandardErrorEncoding = Encoding.UTF8; buildProcess.Start(); var outputTask = Task.Factory.StartNew(() => { var buffer = new char[512]; while (true) { var read = buildProcess.StandardOutput.Read(buffer, 0, 512); if (read > 0) { try { stdoutWriter?.Write(buffer, 0, read); } catch (Exception ex) { TraceEx.TraceError($"Unable to write standard output, details: {ex}"); } } else { break; } } }, TaskCreationOptions.LongRunning); var errorTask = Task.Factory.StartNew(() => { var buffer = new char[512]; while (true) { var read = buildProcess.StandardError.Read(buffer, 0, 512); if (read > 0) { try { stderrWriter?.Write(buffer, 0, read); } catch (Exception ex) { TraceEx.TraceError($"Unable to write error output, details: {ex}"); } } else { break; } } }, TaskCreationOptions.LongRunning); try { if (buildProcess.WaitForExit(timeoutInMilliseconds)) { return(buildProcess.ExitCode); } else { buildProcess.Kill(); buildProcess.WaitForExit(); throw new TimeoutException($"{executionInfo.ExeFilePath} (argument: {executionInfo.Arguments}, working directory: {executionInfo.WorkingDirectory}) didn't exit in {timeoutInMilliseconds} ms. Force to exit."); } } finally { outputTask.Wait(); errorTask.Wait(); } } }