public override bool Execute(UpdateInput input) { var solution = Solution.For(input); if (input.NugetFlag.IsNotEmpty() && !solution.Dependencies.Has(input.NugetFlag)) { RippleAssert.Fail(input.NugetFlag + " is not a configured dependency"); return(false); } if (input.PreviewFlag) { preview(input, solution); return(true); } return(RippleOperation .For <UpdateInput>(input) .Step <NugetOperation>() .Step <DownloadMissingNugets>() .Step <ExplodeDownloadedNugets>() .Step <ProcessDirectives>() .Step <FixReferences>() .Execute()); }
public void CreateSymbolsPackage(PackageParams ctx) { var symbolsBuilder = symbolsPackageBuilderFor(ctx.Spec, ctx.Version); // remove unnecessary files when building the symbols package ExcludeFilesForSymbolPackage(symbolsBuilder.Files); if (!symbolsBuilder.Files.Any()) { RippleLog.Info("No symbols could be generated for {0} since no symbol files could be found. This is expected if this is a code only package".ToFormat(ctx.Spec.Name)); return; } var nupkgSymbolsFileName = Path.Combine(ctx.OutputPath, "{0}.{1}.symbols.nupkg".ToFormat(ctx.Spec.Name, ctx.Version)); var package = createPackage(symbolsBuilder, nupkgSymbolsFileName); var issues = package.Validate(Rules); if (issues.Any(x => x.Level == PackageIssueLevel.Error)) { Console.ForegroundColor = ConsoleColor.Red; issues.Each(issue => Console.WriteLine("[{0}] {1} - {2}", issue.Level, issue.Title, issue.Description)); Console.ResetColor(); RippleAssert.Fail("Symbols package failed validation"); } }
public static BatchOperation Parse(Solution solution, string input) { var operation = new BatchOperation(solution); input.ReadLines(line => { if (line.IsEmpty()) { return; } var tokens = line.Split(':'); if (tokens.Length == 1) { RippleAssert.Fail("expected \":\" - {0}", line); } else if (tokens.Length != 2) { RippleAssert.Fail("unexpected \":\" - {0}", line); } var requests = parseLine(solution, tokens); operation._requests.AddRange(requests); }); return(operation); }
public override bool Execute(PublishInput input) { var report = new PublishReport(); input.EachSolution(solution => { RippleLog.Info("Building nuget files for " + solution.Name); var artifactDirectory = solution.Directory.AppendPath(input.ArtifactsFlag); RippleLog.Info("Cleaning out any existing nuget files before continuing"); new FileSystem().CleanDirectory(artifactDirectory); solution.Specifications.Each(nuget => { RippleLog.Info("Creating and publishing Nuget for " + nuget.Name); var packageFile = solution.Package(new PackageParams(nuget, SemanticVersion.Parse(input.Version), artifactDirectory, input.CreateSymbolsFlag)); var detail = solution.Publisher.PublishPackage(input.ServerFlag, packageFile, input.ApiKey); report.Add(detail); }); }); RippleLog.InfoMessage(report); if (!report.IsSuccessful()) { RippleAssert.Fail("Failure publishing packages"); } return(true); }
public override bool Execute(BatchPublishInput input) { RippleLog.Info("Looking for *.nupkg files in " + input.Directory); var files = new FileSystem() .FindFiles(input.Directory, new FileSet { Include = "*.nupkg" }) .ToArray(); _index = 0; _count = files.Count(); var publisher = PublishingService.Basic(); var report = new PublishReport(); files.Each(file => { _index++; RippleLog.Info("Trying to publish {0}, {1} or {2}".ToFormat(file, _index, _count)); var detail = publisher.PublishPackage(input.ServerFlag, file, input.ApiKeyFlag); report.Add(detail); }); RippleLog.InfoMessage(report); if (!report.IsSuccessful()) { RippleAssert.Fail("Failure publishing packages"); } return(true); }
public string CreatePackage(PackageParams ctx) { var builder = packageBuilderFor(ctx.Spec, ctx.Version); if (ctx.CreateSymbols) { ExcludeFilesForLibPackage(builder.Files); if (!builder.Files.Any()) { throw new CreateNugetException(builder.Id); } } var nupkgFileName = Path.Combine(ctx.OutputPath, "{0}.{1}.nupkg".ToFormat(ctx.Spec.Name, ctx.Version)); var package = createPackage(builder, nupkgFileName); if (ctx.CreateSymbols) { CreateSymbolsPackage(ctx); } var issues = package.Validate(Rules); if (issues.Any(x => x.Level == PackageIssueLevel.Error)) { Console.ForegroundColor = ConsoleColor.Red; issues.Each(issue => Console.WriteLine("[{0}] {1} - {2}", issue.Level, issue.Title, issue.Description)); Console.ResetColor(); RippleAssert.Fail("Package failed validation"); } return(nupkgFileName); }
public void CreateSymbolsPackage(PackageParams ctx) { var symbolsBuilder = symbolsPackageBuilderFor(ctx.Spec, ctx.Version); // remove unnecessary files when building the symbols package ExcludeFilesForSymbolPackage(symbolsBuilder.Files); if (!symbolsBuilder.Files.Any()) { throw new CreateNugetException(symbolsBuilder.Id, true); } var nupkgSymbolsFileName = Path.Combine(ctx.OutputPath, "{0}.{1}.symbols.nupkg".ToFormat(ctx.Spec.Name, ctx.Version)); var package = createPackage(symbolsBuilder, nupkgSymbolsFileName); var issues = package.Validate(Rules); if (issues.Any(x => x.Level == PackageIssueLevel.Error)) { Console.ForegroundColor = ConsoleColor.Red; issues.Each(issue => Console.WriteLine("[{0}] {1} - {2}", issue.Level, issue.Title, issue.Description)); Console.ResetColor(); RippleAssert.Fail("Symbols package failed validation"); } }
public void AssertIsValid() { var element = findNugetElement("id"); if (element == null) { RippleAssert.Fail("Invalid nuspec document"); } }
private ISolutionLoader findLoader() { var solutionLoader = Loaders.FirstOrDefault(x => x.Condition.Matches(_fileSystem, RootDir)); if (solutionLoader == null) { RippleAssert.Fail("Unable to determine ripple mode. See the log for further details or use the --verbose option."); } return(solutionLoader); }
private IRemoteNuget nugetFor(Dependency dependency, bool retrying = false) { IRemoteNuget nuget = null; var feeds = _connectivity.FeedsFor(_solution); foreach (var feed in feeds) { _connectivity.IfOnline(feed, x => nuget = getLatestFromFloatingFeed(x, dependency)); if (nuget != null) { break; } if (dependency.IsFloat() || dependency.Version.IsEmpty()) { _connectivity.IfOnline(feed, x => nuget = x.FindLatest(dependency)); if (nuget != null && dependency.Version.IsNotEmpty() && nuget.Version < dependency.SemanticVersion()) { nuget = null; continue; } if (nuget != null) { break; } } _connectivity.IfOnline(feed, x => nuget = x.Find(dependency)); if (nuget != null) { break; } } if (nuget == null) { if (_connectivity.AllOffline(feeds) && !retrying) { return(nugetFor(dependency, true)); } feeds.OfType <FloatingFileSystemNugetFeed>() .Each(files => files.DumpLatest()); RippleAssert.Fail("Could not find " + dependency); } return(remoteOrCached(nuget)); }
public void AssertIsValid() { var result = Validate(); if (result.IsValid()) { return; } ; RippleLog.InfoMessage(result); RippleAssert.Fail("Validation failed"); }
public void AssertNoLockedFiles() { if (!HasLockedFiles()) { return; } if (Process.GetProcessesByName("devenv.exe").Any()) { RippleAssert.Fail("Detected locked files. Do you have Visual Studio open?"); return; } RippleAssert.Fail("Detected locked files. Exiting."); }
private PackageBuilder packageBuilderFor(NugetSpec spec, SemanticVersion version) { try { return(new PackageBuilder(spec.Filename, NullPropertyProvider.Instance, true) { Version = version }); } catch (Exception exc) { RippleAssert.Fail("Error creating package: " + exc.Message); return(null); } }
protected override void execute(FloatInput input, IRippleStepRunner runner) { var dependency = Solution.Dependencies.Find(input.Name); if (dependency == null) { RippleAssert.Fail("Could not find " + input.Name); return; } dependency.Float(); if (input.MinVersionFlag.IsNotEmpty()) { dependency.Version = input.MinVersionFlag; } }
public static void Live() { _canDetect = () => Directory.Exists(GitDirectory); _detectCurrent = () => { if (!_canDetect()) { RippleAssert.Fail("Cannot use branch detection when not in a git repository"); } var head = File.ReadAllText(Path.Combine(GitDirectory, "HEAD")); return(head.Substring(head.LastIndexOf("/") + 1).Trim()); }; reset(); }
public static void Live() { _canDetect = () => detectBranch().ExitCode == 0; _detectCurrent = () => { var returnValue = detectBranch(); if (returnValue.ExitCode != 0) { RippleAssert.Fail("Cannot use branch detection when not in a git repository"); } var output = returnValue.OutputText; return(output.Substring(output.LastIndexOf('/') + 1).Replace("\n", string.Empty).Replace("\r", string.Empty).Trim()); }; reset(); }
public override bool Execute(InitInput input) { var rippleConfigDirectory = RippleFileSystem.FindSolutionDirectory(false); if (rippleConfigDirectory.IsNotEmpty()) { RippleAssert.Fail(ExistingSolution.ToFormat(rippleConfigDirectory)); return(false); } var builder = NewSolutionBuilder(input.ToSolution()); var solution = builder.Build(); solution.Save(true); return(true); }
public void Execute(RippleInput input, IRippleStepRunner runner) { var feeds = Solution.Feeds.ToArray(); if (input is IOverrideFeeds) { var overrides = input.As <IOverrideFeeds>().Feeds(); if (overrides.Any()) { Solution.ClearFeeds(); Solution.AddFeeds(overrides); } } if (input is IAllowExplicitBranch) { var branchingInput = input.As <IAllowExplicitBranch>(); if (branchingInput.BranchFlag.IsNotEmpty()) { BranchDetector.SetBranch(branchingInput.BranchFlag); } } var missing = Solution.MissingNugets().ToList(); var nugets = new List <INugetFile>(); var report = new MissingNugetReport(); if (missing.Any()) { var tasks = missing.Select(x => restore(x, Solution, report, nugets)).ToArray(); Task.WaitAll(tasks); } Solution.ClearFeeds(); Solution.AddFeeds(feeds); if (!report.IsValid()) { RippleLog.InfoMessage(report); RippleAssert.Fail("Could not restore dependencies"); } runner.Set(new DownloadedNugets(nugets)); }
public string CreatePackage(NugetSpec spec, SemanticVersion version, string outputPath) { var builder = packageBuilderFor(spec, version); var nupkgFileName = Path.Combine(outputPath, "{0}.{1}.nupkg".ToFormat(spec.Name, version)); var package = createPackage(builder, nupkgFileName); var issues = package.Validate(Rules); if (issues.Any(x => x.Level == PackageIssueLevel.Error)) { Console.ForegroundColor = ConsoleColor.Red; issues.Each(issue => Console.WriteLine("[{0}] {1} - {2}", issue.Level, issue.Title, issue.Description)); Console.ResetColor(); RippleAssert.Fail("Package failed validation"); } return(nupkgFileName); }
public override bool Execute(InstallInput input) { var solution = Solution.For(input); if (input.ProjectFlag.IsNotEmpty()) { var project = solution.FindProject(input.ProjectFlag); if (project == null) { RippleAssert.Fail("Project " + input.ProjectFlag + " does not exist"); return(false); } if (project.Dependencies.Has(input.Package)) { RippleAssert.Fail(input.Package + " already exists in Project " + input.ProjectFlag); return(false); } } else if (solution.Dependencies.Has(input.Package)) { RippleAssert.Fail(input.Package + " already exists in solution"); return(false); } if (input.PreviewFlag) { preview(input, solution); return(true); } return(RippleOperation .For <InstallInput>(input) .Step <NugetOperation>() .Step <DownloadMissingNugets>() .Step <ExplodeDownloadedNugets>() .Step <FixReferences>() .Execute()); }
private IPackage createPackage(PackageBuilder builder, string outputPath) { bool isExistingPackage = File.Exists(outputPath); try { using (Stream stream = File.Create(outputPath)) { builder.Save(stream); } } catch (Exception exc) { if (!isExistingPackage && File.Exists(outputPath)) { File.Delete(outputPath); } RippleAssert.Fail("Error creating package: " + exc.Message); } RippleLog.Info("Created nuget at: " + outputPath); return(new OptimizedZipPackage(outputPath)); }
public override bool Execute(InitInput input) { var rippleConfigDirectory = RippleFileSystem.FindSolutionDirectory(false); if (rippleConfigDirectory.IsNotEmpty()) { RippleAssert.Fail(ExistingSolution.ToFormat(rippleConfigDirectory)); return(false); } SolutionFiles.AddLoader(new NuGetSolutionLoader()); var builder = Builder(); var solution = builder.Build(); solution.Save(true); new CleanCommand().Execute(new CleanInput()); new RestoreCommand().Execute(new RestoreInput { FixReferencesFlag = true }); return(true); }
private IEnumerable <Dependency> findDependenciesFor(Dependency dependency, UpdateMode mode, SearchLocation location) { var dependencies = new List <Dependency>(); var task = findDependenciesFor(dependency, mode, 0, location, dependencies); try { task.Wait(); if (!task.Result.Found) { RippleAssert.Fail("Could not find " + dependency.Name); } } catch (AggregateException ex) { var flat = ex.Flatten(); if (flat.InnerException != null) { RippleLog.Debug(flat.InnerException.Message); } } return(dependencies.OrderBy(x => x.Name)); }
private NugetPlan buildPlan(NugetPlanRequest request, Dependency parent = null) { var plan = new NugetPlan(); var target = request.Dependency; var solution = request.Solution; var dependencyKey = target.Copy(); if (dependencyKey.IsFloat()) { dependencyKey = target.AsFloat(); } var key = new PlanKey(dependencyKey, request.Project); if (_planCache.Has(key)) { return(_planCache[key]); } _planCache.Fill(key, plan); RippleLog.Info("* Analyzing " + target); if (target.Version.IsEmpty()) { string version = null; var local = solution.LocalDependencies(); if (request.Operation == OperationType.Install && solution.LocalDependencies().Has(target)) { var localNuget = local.Get(target); version = localNuget.Version.ToString(); } else { if (!RippleEnvironment.Connected()) { RippleAssert.Fail("Cannot update in offline mode"); } var task = solution.FeedService.NugetFor(target); task.Wait(); if (!task.Result.Found) { RippleAssert.Fail("Could not find " + request.Dependency); } var remote = task.Result.Nuget; version = remote.Version.ToString(); } target.Version = version; } if (request.UpdatesCurrentDependency()) { updateDependency(plan, request); } else if (!solution.Dependencies.Has(target.Name)) { plan.AddStep(new InstallSolutionDependency(target)); } projectInstallations(plan, parent, request); var location = request.Operation == OperationType.Install ? SearchLocation.Local : SearchLocation.Remote; var nugetDependencies = solution.FeedService.DependenciesFor(target, target.Mode, location); nugetDependencies.Each(x => { var transitiveDep = request.CopyFor(x); var childPlan = buildPlan(transitiveDep, target); plan.Import(childPlan); }); return(plan); }