Esempio n. 1
0
 public Tester(
     IFileSystem fileSystem,
     IEnvironmentTemporaryDirectoryProvider temporaryDirectoryProvider,
     ITempFolderProvider tempFolderProvider,
     IPrintErrorMessage printErrorMessage,
     IAvailableProjectsRetriever availableProjectsRetriever,
     IModifyRunnerProjects modifyRunnerProjects,
     IBuild build)
 {
     _fileSystem = fileSystem;
     _temporaryDirectoryProvider = temporaryDirectoryProvider;
     _tempFolderProvider         = tempFolderProvider;
     _printErrorMessage          = printErrorMessage;
     _availableProjectsRetriever = availableProjectsRetriever;
     _modifyRunnerProjects       = modifyRunnerProjects;
     _build = build;
 }
Esempio n. 2
0
        public CompilationProvider(
            IGitPatcherCompilation build,
            ILogger logger,
            IPrintErrorMessage printErrorMessage,
            IShortCircuitSettingsProvider shortCircuitSettingsProvider,
            IRunnableStateProvider runnableStateProvider)
        {
            State = runnableStateProvider.WhenAnyValue(x => x.State)
                    .CombineLatest(
                shortCircuitSettingsProvider.WhenAnyValue(x => x.Shortcircuit),
                (state, _) => state)
                    .Select(state =>
            {
                return(Observable.Create <ConfigurationState <RunnerRepoInfo> >(async(observer, cancel) =>
                {
                    if (state.RunnableState.Failed)
                    {
                        observer.OnNext(state);
                        return;
                    }

                    try
                    {
                        logger.Information("Compiling");
                        // Return early with the values, but mark not complete
                        observer.OnNext(new ConfigurationState <RunnerRepoInfo>(state.Item)
                        {
                            IsHaltingError = false,
                            RunnableState = ErrorResponse.Fail("Compiling")
                        });

                        // Compile to help prep
                        var compileResp = await build.Compile(state.Item, cancel).ConfigureAwait(false);
                        if (compileResp.Failed)
                        {
                            logger.Information("Compiling failed: {Reason}", compileResp.Reason);
                            var errs = new List <string>();
                            printErrorMessage.Print(compileResp.Reason,
                                                    $"{Path.GetDirectoryName(state.Item.ProjPath)}\\", (s, _) =>
                            {
                                errs.Add(s.ToString());
                            });
                            observer.OnNext(
                                GetResponse <RunnerRepoInfo> .Fail(string.Join(Environment.NewLine, errs)));
                            return;
                        }

                        // Return things again, without error
                        logger.Information("Finished compiling");
                        observer.OnNext(state);
                    }
                    catch (Exception ex)
                    {
                        logger.Error(ex, "Error compiling");
                        observer.OnNext(ErrorResponse.Fail($"Error compiling: {ex}").BubbleFailure <RunnerRepoInfo>());
                    }

                    observer.OnCompleted();
                }));
            })
                    .Switch()
                    .StartWith(new ConfigurationState <RunnerRepoInfo>(
                                   GetResponse <RunnerRepoInfo> .Fail("Compilation uninitialized")))
                    .Replay(1)
                    .RefCount();
        }