Esempio n. 1
0
        private async Task FinishOutput(BuildState buildState, JobCompletedEventArgs jobCompletedEventArgs)
        {
            if (buildOutputStream != null)
            {
                await buildOutputStream.FlushAsync();

                buildOutputStream.Flush(flushToDisk: true);
                await buildOutputStream.DisposeAsync();
            }

            int extraChars = outputDecoder.GetCharCount(Array.Empty <byte>(), 0, 0, flush: true);

            if (extraChars > 0)
            {
                var decoded = new char[extraChars];
                outputDecoder.GetChars(Array.Empty <byte>(), 0, 0, decoded, 0, flush: true);
                AppendLineChars(decoded);
            }

            await FileUtil.WriteAllTextToDiskAsync(
                Path.Combine(buildDir, "result.json"),
                JsonConvert.SerializeObject(new JobBuildResult {
                State = buildState,
            }),
                Encoding.UTF8,
                CancellationToken.None
                );

            outputLines.Add(currentLine.ToString());
            OutputLinesChanged?.Invoke(this, new OutputLinesChangedEventArgs(outputLines));

            state = buildState;
            complete.TrySetResult(null);
            JobCompleted?.Invoke(this, jobCompletedEventArgs);
        }
Esempio n. 2
0
        private void JobCompleted(object?sender, JobCompletedEventArgs e)
        {
            if (!(sender is IJobStatus status))
            {
                return;
            }

            Task.Run(async() => {
                bool completed;
                using (await outputLock.LockAsync()) {
                    ++completedJobs;
                    if (e.Exception != null)
                    {
                        ++failedJobs;
                        await WriteOutput($"Error occurred while running job {status.Id}.");
                    }
                    else if (e.ExitCode != 0)
                    {
                        ++failedJobs;
                        await WriteOutput($"Job {status.Id} exited with error code {e.ExitCode}.");
                    }
                    else
                    {
                        await WriteOutput($"Job {status.Id} completed successfully.");
                    }

                    completed = (completedJobs == JobsStatus.Count);
                    lock (stateLock) {
                        if (completed)
                        {
                            state = failedJobs == 0 ? BuildState.Successful : BuildState.Failed;
                        }
                    }
                    if (completed)
                    {
                        if (failedJobs == 0)
                        {
                            await WriteOutput("All jobs completed successfully.");
                        }
                        else
                        {
                            await WriteOutput($"All jobs completed. {failedJobs} failed.");
                        }

                        await CloseOutput();

                        var result = new PipelineBuildResult {
                            State = state,
                        };

                        await FileUtil.WriteAllTextToDiskAsync(
                            Path.Combine(buildDir, "result.json"),
                            JsonConvert.SerializeObject(result),
                            Encoding.UTF8,
                            CancellationToken.None
                            );
                    }
                }

                if (completed)
                {
                    PipelineCompleted?.Invoke(this, EventArgs.Empty);
                }
            });
        }