Beispiel #1
0
        static async Task DoWork(
            string? mutagenVersion,
            string? synthesisVersion,
            CancellationToken cancel)
        {
            using var temp = TempFolder.Factory();
            var failedDeps = new List<Dependent>();
            var projResults = new List<(Dependent, string, ErrorResponse)>();

            mutagenVersion ??= Versions.MutagenVersion;
            synthesisVersion ??= Versions.SynthesisVersion;

            System.Console.WriteLine($"Mutagen: {mutagenVersion}");
            System.Console.WriteLine($"Synthesis: {synthesisVersion}");

            var deps = await GitHubDependents.GitHubDependents.GetDependents(
                    user: RegistryConstants.GithubUser,
                    repository: RegistryConstants.GithubRepoName,
                    packageID: RegistryConstants.PackageId,
                    pages: byte.MaxValue)
                .ToArrayAsync();

            await Task.WhenAll(deps.GroupBy(x => x.User).Select(group => Task.Run(async () =>
            {
                cancel.ThrowIfCancellationRequested();
                if (group.Key == null) return;

                await Task.WhenAll(group.Select(dependency => Task.Run(async () =>
                {
                    cancel.ThrowIfCancellationRequested();
                    try
                    {
                        if (dependency.User.IsNullOrWhitespace() || dependency.Repository.IsNullOrWhitespace()) return;
                        var repoDir = Directory.CreateDirectory(Path.Combine(temp.Dir.Path, group.Key, dependency.Repository));
                        var clonePath = $"https://github.com/{dependency.User}/{dependency.Repository}";
                        try
                        {
                            Repository.Clone(clonePath, repoDir.FullName);
                        }
                        catch (Exception ex)
                        {
                            System.Console.Error.WriteLine($"Failed to clone {clonePath}");
                            System.Console.Error.WriteLine(ex);
                            failedDeps.Add(dependency);
                            return;
                        }

                        cancel.ThrowIfCancellationRequested();
                        using var repo = new Repository(repoDir.FullName);
                        var slnPath = GitPatcherRun.GetPathToSolution(repo.Info.WorkingDirectory);
                        if (slnPath == null)
                        {
                            System.Console.Error.WriteLine($"Could not get path to solution {clonePath}");
                            failedDeps.Add(dependency);
                            return;
                        }

                        GitPatcherRun.SwapInDesiredVersionsForSolution(
                            solutionPath: slnPath,
                            drivingProjSubPath: string.Empty,
                            mutagenVersion: mutagenVersion,
                            out var _,
                            synthesisVersion: synthesisVersion,
                            out var _);

                        foreach (var proj in SolutionPatcherRun.AvailableProjectSubpaths(slnPath))
                        {
                            System.Console.WriteLine($"Checking {group.Key}/{dependency.Repository}:{proj}");
                            cancel.ThrowIfCancellationRequested();
                            var path = Path.Combine(repoDir.FullName, proj);
                            var compile = await DotNetCommands.Compile(path, cancel, null);
                            if (compile.Failed)
                            {
                                System.Console.WriteLine("Failed compilation");
                            }
                            projResults.Add((dependency, proj, compile));
                        }
                    }
                    catch (Exception ex)
                    {
                        System.Console.Error.WriteLine($"Failed to check {dependency}");
                        System.Console.Error.WriteLine(ex);
                        return;
                    }
                })));
            })));

            cancel.ThrowIfCancellationRequested();
            System.Console.WriteLine();
            System.Console.WriteLine();
            System.Console.WriteLine();
            System.Console.WriteLine("-------------------------------");
            System.Console.WriteLine();
            System.Console.WriteLine();
            System.Console.WriteLine();

            if (failedDeps.Count > 0)
            {
                System.Console.WriteLine("Failed repos:");
                foreach (var f in failedDeps
                    .OrderBy(d => d.User)
                    .CreateOrderedEnumerable(d => d.Repository, null, true))
                {
                    System.Console.WriteLine($"   {f}");
                }
            }

            var failed = projResults.Where(p => p.Item3.Failed).ToList();
            if (failed.Count > 0)
            {
                System.Console.WriteLine("Failed projects:");
                foreach (var f in failed.OrderBy(f => f.Item1.User)
                    .CreateOrderedEnumerable(d => d.Item1.Repository, null, true)
                    .CreateOrderedEnumerable(d => d.Item2, null, true))
                {
                    System.Console.WriteLine($"{f.Item1}: {f.Item2}");
                    System.Console.WriteLine();
                }
            }
        }
Beispiel #2
0
        public ExistingProjectInitVM()
        {
            SolutionPath.PathType         = PathPickerVM.PathTypeOptions.File;
            SolutionPath.ExistCheckOption = PathPickerVM.CheckOptions.On;
            SolutionPath.Filters.Add(new CommonFileDialogFilter("Solution", ".sln"));

            AvailableProjects = this.WhenAnyValue(x => x.SolutionPath.TargetPath)
                                .ObserveOn(RxApp.TaskpoolScheduler)
                                .Select(x => SolutionPatcherRun.AvailableProjectSubpaths(x))
                                .Select(x => x.AsObservableChangeSet())
                                .Switch()
                                .ObserveOnGui()
                                .ToObservableCollection(this);

            InitializationCall = SelectedProjects.Connect()
                                 .Transform(subPath =>
            {
                if (subPath == null || this.SolutionPath.TargetPath == null)
                {
                    return(string.Empty);
                }
                try
                {
                    return(Path.Combine(Path.GetDirectoryName(SolutionPath.TargetPath) !, subPath));
                }
                catch (Exception)
                {
                    return(string.Empty);
                }
            })
                                 .Transform(path =>
            {
                var pathPicker = new PathPickerVM
                {
                    PathType         = PathPickerVM.PathTypeOptions.File,
                    ExistCheckOption = PathPickerVM.CheckOptions.On,
                    TargetPath       = path
                };
                pathPicker.Filters.Add(new CommonFileDialogFilter("Project", ".csproj"));
                return(pathPicker);
            })
                                 .DisposeMany()
                                 .QueryWhenChanged(q =>
            {
                if (q.Count == 0)
                {
                    return(GetResponse <InitializerCall> .Fail("No projects selected"));
                }
                var err = q
                          .Select(p => p.ErrorState)
                          .Where(e => e.Failed)
                          .And(ErrorResponse.Success)
                          .First();
                if (err.Failed)
                {
                    return(err.BubbleFailure <InitializerCall>());
                }
                return(GetResponse <InitializerCall> .Succeed(async(profile) =>
                {
                    return q.Select(i =>
                    {
                        var patcher = new SolutionPatcherVM(profile);
                        patcher.SolutionPath.TargetPath = SolutionPath.TargetPath;
                        patcher.ProjectSubpath = i.TargetPath.TrimStart($"{Path.GetDirectoryName(SolutionPath.TargetPath)}\\" !);
                        return patcher;
                    });
                }));
            });
        }