protected async Task LoadSecretsIfNecessaryAsync() { if (SecretEncrypterFunction != null) { return; } var encrypterSecret = new SecretStringEncrypterFunction(); var errorsAndInfos = new ErrorsAndInfos(); var csLambda = await SecretRepository.GetAsync(encrypterSecret, errorsAndInfos); SecretEncrypterFunction = await SecretRepository.CompileCsLambdaAsync <string, string>(csLambda); var decrypterSecret = new SecretStringDecrypterFunction(); csLambda = await SecretRepository.GetAsync(decrypterSecret, errorsAndInfos); SecretDecrypterFunction = await SecretRepository.CompileCsLambdaAsync <string, string>(csLambda); if (!errorsAndInfos.AnyErrors()) { return; } throw new Exception(errorsAndInfos.ErrorsToString()); }
private async Task FindReplacementsIfNecessaryAsync() { if (Replacements.Any()) { return; } var errorsAndInfos = new ErrorsAndInfos(); var machineDrivesSecret = new MachineDrivesSecret(); var machineDrives = await SecretRepository.GetAsync(machineDrivesSecret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } machineDrives.DrivesOnThisMachine().ToList().ForEach(AddReplacement); var logicalFoldersSecret = new LogicalFoldersSecret(); var logicalFolders = await SecretRepository.GetAsync(logicalFoldersSecret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(errorsAndInfos.ErrorsToString()); } logicalFolders.ForEach(AddReplacement); var keys = Replacements.Keys.ToList(); foreach (var key in keys) { Replacements[key] = ResolveIterative(Replacements[key]).FullName; } }
private async Task <PersonalAccessTokens> GetPersonalAccessTokensAsync(IErrorsAndInfos errorsAndInfos) { var personalAccessTokensSecret = new PersonalAccessTokensSecret(); var personalAccessTokens = await vSecretRepository.GetAsync(personalAccessTokensSecret, errorsAndInfos); return(personalAccessTokens); }
public async Task <IActionResult> GetSecretAsync([FromRoute] string id, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(id, out var guid) || guid.Equals(Guid.Empty)) { var error = ErrorResponsesService.NotFoundError(Target, $"Secret with id '{id}' not found."); return(NotFound(error)); } Model.Secret modelSecret; try { modelSecret = await repository.GetAsync(guid, cancellationToken).ConfigureAwait(false); } catch (SecretNotFoundException ex) { var error = ErrorResponsesService.NotFoundError(Target, ex.Message); return(NotFound(error)); } var clientSecret = Converter.SecretConverter.Convert(modelSecret); return(Ok(clientSecret)); }
private static async Task <ShouldDefaultSecretsBeStored> ShouldDefaultSecretsBeStoredAsync(ISecretRepository sut, IErrorsAndInfos errorsAndInfos) { var secret = new SecretShouldDefaultSecretsBeStored(); var shouldDefaultSecretsBeStored = await sut.GetAsync(secret, errorsAndInfos); Assert.IsNotNull(shouldDefaultSecretsBeStored); return(shouldDefaultSecretsBeStored); }
public async Task <IEnumerable <BackbendFolderToBeArchived> > AnalyzeAsync(IErrorsAndInfos errorsAndInfos) { var result = new List <BackbendFolderToBeArchived>(); var backbendFolders = await SecretRepository.GetAsync(new BackbendFoldersSecret(), errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(result); } await backbendFolders.ResolveAsync(FolderResolver, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(result); } var archiveFolderFinderSecret = await SecretRepository.GetAsync(new ArchiveFolderFinderSecret(), errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(result); } var archiveFolderFinder = await SecretRepository.CompileCsLambdaAsync <string, string>(archiveFolderFinderSecret); if (archiveFolderFinder == null) { errorsAndInfos.Errors.Add(Properties.Resources.CouldNotCompileFolderFinder); return(result); } foreach (var backbendFolder in backbendFolders) { AnalyzeFolderAsync(backbendFolder, archiveFolderFinder, result); foreach (var subFolder in Directory.GetDirectories(backbendFolder.GetFolder().FullName).Select(f => new BackbendFolder { Name = f })) { subFolder.SetFolder(new Folder(subFolder.Name)); AnalyzeFolderAsync(subFolder, archiveFolderFinder, result); } } return(result); }
private async Task <bool> UpdateNugetPackagesForProjectAsync(string projectFileFullName, bool yesNo, IErrorsAndInfos errorsAndInfos) { using (SimpleLogger.BeginScope(SimpleLoggingScopeId.Create(nameof(UpdateNugetPackagesForProjectAsync), Guid.NewGuid().ToString()))) { SimpleLogger.LogInformation("Retrieving dependency ids and versions"); var dependencyErrorsAndInfos = new ErrorsAndInfos(); var dependencyIdsAndVersions = await PackageConfigsScanner.DependencyIdsAndVersionsAsync(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')), true, true, dependencyErrorsAndInfos); SimpleLogger.LogInformation("Retrieving manually updated packages"); var secret = new SecretManuallyUpdatedPackages(); var manuallyUpdatedPackages = await SecretRepository.GetAsync(secret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { SimpleLogger.LogInformation("Returning false"); return(false); } foreach (var id in dependencyIdsAndVersions.Select(dependencyIdsAndVersion => dependencyIdsAndVersion.Key).Where(id => manuallyUpdatedPackages.All(p => p.Id != id))) { SimpleLogger.LogInformation($"Updating dependency {id}"); var projectFileFolder = new Folder(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\'))); ProcessRunner.RunProcess("dotnet", "remove " + projectFileFullName + " package " + id, projectFileFolder, errorsAndInfos); ProcessRunner.RunProcess("dotnet", "add " + projectFileFullName + " package " + id, projectFileFolder, errorsAndInfos); } SimpleLogger.LogInformation("Retrieving dependency ids and versions once more"); var dependencyIdsAndVersionsAfterUpdate = await PackageConfigsScanner.DependencyIdsAndVersionsAsync(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')), true, true, dependencyErrorsAndInfos); SimpleLogger.LogInformation("Determining differences"); foreach (var dependencyIdsAndVersion in dependencyIdsAndVersionsAfterUpdate) { var id = dependencyIdsAndVersion.Key; var version = dependencyIdsAndVersion.Value; yesNo = yesNo || !dependencyIdsAndVersions.ContainsKey(id) || version != dependencyIdsAndVersions[id]; } SimpleLogger.LogInformation($"Returning {yesNo}"); return(yesNo); } }
private async Task <IList <DvinApp> > LoadAsync(bool resolve, IErrorsAndInfos errorsAndInfos) { var dvinAppsSecret = new SecretDvinApps(); var secretDvinApps = await SecretRepository.GetAsync(dvinAppsSecret, errorsAndInfos); if (!resolve || errorsAndInfos.AnyErrors()) { return(secretDvinApps); } await secretDvinApps.ResolveFoldersAsync(FolderResolver, errorsAndInfos); return(secretDvinApps); }
public async Task SetBenchmarkDefinitionsAsync() { var secret = new SecretBenchmarkDefinitions(); var errorsAndInfos = new ErrorsAndInfos(); BenchmarkDefinitions = await SecretRepository.GetAsync(secret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { throw new Exception(string.Join("\r\n", errorsAndInfos.Errors)); } SelectedBenchmarkDefinition = BenchmarkDefinitions[0]; BenchmarkExecutions = new ObservableCollection <IBenchmarkExecution>(); BenchmarkExecutionStates = new ObservableCollection <IBenchmarkExecutionState>(); DisplayedBenchmarkExecutionStates = new ObservableCollection <IDisplayedBenchmarkExecutionState>(); BenchmarkDefinitions.CollectionChanged += BenchmarkDefinitionsOnCollectionChanged; BenchmarkExecutionStates.CollectionChanged += BenchmarkExecutionStatesOnCollectionChanged; }
public async Task <string> Disguise(ISecretRepository secretRepository, string s, IErrorsAndInfos errorsAndInfos) { var bytes = Encoding.UTF8.GetBytes(s); EnsurePrimeNumbers(bytes); long pos = bytes.Length; var primePos = bytes.Length; var disguised = ""; var secretLongString = await secretRepository.GetAsync(new LongSecretString(), errorsAndInfos); var longString = secretLongString.TheLongString; foreach (var aByte in bytes) { pos += aByte * PrimeNumbers[primePos]; primePos += aByte; disguised += longString.Substring((int)(pos % (longString.Length - 3)), 3); } return(disguised); }
private async Task AutoCommitAndPushAsync(string nugetFeedId, IFolder repositoryFolder, List <string> files, bool onlyIfNecessary, string commitMessage, bool noRebuildRequired, IErrorsAndInfos errorsAndInfos) { var branchName = GitUtilities.CheckedOutBranch(repositoryFolder); if (branchName != "master") { errorsAndInfos.Errors.Add(Properties.Resources.CheckedOutBranchIsNotMaster); return; } var headTipShaBeforePush = GitUtilities.HeadTipIdSha(repositoryFolder); GitUtilities.IdentifyOwnerAndName(repositoryFolder, out var owner, out _, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { errorsAndInfos.Errors.Add(Properties.Resources.OwnerAndNameNotFound); return; } var personalAccessTokensSecret = new PersonalAccessTokensSecret(); var personalAccessTokens = await SecretRepository.GetAsync(personalAccessTokensSecret, errorsAndInfos); var personalAccessToken = personalAccessTokens.FirstOrDefault(t => t.Owner == owner && t.Purpose == "AutoCommitPush"); if (personalAccessToken == null) { errorsAndInfos.Errors.Add(Properties.Resources.AutoCommitPushAccessTokenNotFound); return; } using var repo = new Repository(repositoryFolder.FullName); var remotes = repo.Network.Remotes.ToList(); if (remotes.Count != 1) { errorsAndInfos.Errors.Add(Properties.Resources.RemoteNotFoundOrNotUnique); return; } var remote = remotes[0]; files.ForEach(f => { // ReSharper disable once AccessToDisposedClosure Commands.Stage(repo, f); }); var checkFiles = GitUtilities.FilesWithUncommittedChanges(repositoryFolder); if (onlyIfNecessary && !checkFiles.Any()) { return; } if (checkFiles.Count != files.Count) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.NumberOfFilesWithUncommittedChangesHasChanged, string.Join(", ", files), string.Join(", ", checkFiles))); return; } var author = new Signature(personalAccessToken.TokenName, personalAccessToken.Email, DateTime.Now); var committer = author; repo.Commit(commitMessage, author, committer); var options = new PushOptions { CredentialsProvider = (_, _, _) => new UsernamePasswordCredentials { Username = owner, Password = personalAccessToken.Token } }; repo.Network.Push(remote, @"refs/heads/" + branchName, options); if (!noRebuildRequired) { return; } var pushedHeadTipShaRepository = PushedHeadTipShaRepository; if (!(await pushedHeadTipShaRepository.GetAsync(nugetFeedId, errorsAndInfos)).Contains(headTipShaBeforePush)) { return; } var headTipSha = GitUtilities.HeadTipIdSha(repositoryFolder); await pushedHeadTipShaRepository.AddAsync(nugetFeedId, headTipSha, errorsAndInfos); }
public async Task <IPackageToPush> FindPackageToPushAsync(string nugetFeedId, IFolder packageFolderWithBinaries, IFolder repositoryFolder, string solutionFileFullName, IErrorsAndInfos errorsAndInfos) { IPackageToPush packageToPush = new PackageToPush(); errorsAndInfos.Infos.Add(Properties.Resources.CheckingProjectVsSolution); var projectFileFullName = solutionFileFullName.Replace(".sln", ".csproj"); if (!File.Exists(projectFileFullName)) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.ProjectFileNotFound, projectFileFullName)); return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.LoadingProject); var project = ProjectFactory.Load(solutionFileFullName, projectFileFullName, errorsAndInfos); if (errorsAndInfos.Errors.Any()) { return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.LoadingNugetFeeds); var developerSettingsSecret = new DeveloperSettingsSecret(); var developerSettings = await SecretRepository.GetAsync(developerSettingsSecret, errorsAndInfos); if (errorsAndInfos.Errors.Any()) { return(packageToPush); } if (developerSettings == null) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.MissingDeveloperSettings, developerSettingsSecret.Guid + ".xml")); return(packageToPush); } var nugetFeedsSecret = new SecretNugetFeeds(); var nugetFeeds = await SecretRepository.GetAsync(nugetFeedsSecret, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.IdentifyingNugetFeed); var nugetFeed = nugetFeeds.FirstOrDefault(f => f.Id == nugetFeedId); if (nugetFeed == null) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.UnknownNugetFeed, nugetFeedId, nugetFeedsSecret.Guid + ".xml")); return(packageToPush); } if (!nugetFeed.IsAFolderToResolve()) { var nugetConfigFileFullName = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\NuGet\" + "nuget.config"; packageToPush.ApiKey = NugetConfigReader.GetApiKey(nugetConfigFileFullName, nugetFeed.Id, errorsAndInfos); if (errorsAndInfos.Errors.Any()) { return(packageToPush); } } errorsAndInfos.Infos.Add(Properties.Resources.IdentifyingFeedUrl); var source = await nugetFeed.UrlOrResolvedFolderAsync(FolderResolver, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(packageToPush); } packageToPush.FeedUrl = source; if (string.IsNullOrEmpty(packageToPush.FeedUrl)) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.IncompleteDeveloperSettings, developerSettingsSecret.Guid + ".xml")); return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.SearchingLocalPackage); var localPackageRepository = new FindLocalPackagesResourceV2(packageFolderWithBinaries.FullName); var localPackages = localPackageRepository.GetPackages(new NullLogger(), CancellationToken.None).Where(p => !p.Identity.Version.IsPrerelease).ToList(); if (!localPackages.Any()) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.NoPackageFilesFound, packageFolderWithBinaries.FullName)); return(packageToPush); } var latestLocalPackageVersion = localPackages.Max(p => p.Identity.Version.Version); errorsAndInfos.Infos.Add(string.Format(Properties.Resources.FoundLocalPackage, latestLocalPackageVersion)); errorsAndInfos.Infos.Add(Properties.Resources.SearchingRemotePackage); var packageId = string.IsNullOrWhiteSpace(project.PackageId) ? project.RootNamespace : project.PackageId; var remotePackages = await NugetFeedLister.ListReleasedPackagesAsync(nugetFeedId, packageId, errorsAndInfos); if (errorsAndInfos.Errors.Any()) { return(packageToPush); } if (!remotePackages.Any()) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.NoRemotePackageFilesFound, packageToPush.FeedUrl, packageId)); return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.LoadingPushedHeadTipShas); var pushedHeadTipShas = await PushedHeadTipShaRepository.GetAsync(nugetFeedId, errorsAndInfos); if (errorsAndInfos.AnyErrors()) { return(packageToPush); } var headTipIdSha = repositoryFolder == null ? "" : GitUtilities.HeadTipIdSha(repositoryFolder); if (!string.IsNullOrWhiteSpace(headTipIdSha) && pushedHeadTipShas.Contains(headTipIdSha)) { errorsAndInfos.Infos.Add(string.Format(Properties.Resources.HeadTipShaHasAlreadyBeenPushed, headTipIdSha, nugetFeedId)); return(packageToPush); } var latestRemotePackageVersion = remotePackages.Max(p => p.Identity.Version.Version); errorsAndInfos.Infos.Add(string.Format(Properties.Resources.FoundRemotePackage, latestRemotePackageVersion)); if (latestRemotePackageVersion >= latestLocalPackageVersion) { errorsAndInfos.Infos.Add(string.Format(Properties.Resources.RemotePackageHasHigherOrEqualVersion, headTipIdSha)); return(packageToPush); } errorsAndInfos.Infos.Add(Properties.Resources.CheckingRemotePackageTag); var remotePackage = remotePackages.First(p => p.Identity.Version.Version == latestRemotePackageVersion); if (!string.IsNullOrEmpty(remotePackage.Tags) && !string.IsNullOrWhiteSpace(headTipIdSha)) { errorsAndInfos.Infos.Add(string.Format(Properties.Resources.TagsAre, remotePackage.Tags)); var tags = remotePackage.Tags.Split(' ').ToList(); if (tags.Contains(headTipIdSha)) { errorsAndInfos.Infos.Add(string.Format(Properties.Resources.PackageAlreadyTaggedWithHeadTipSha, headTipIdSha)); return(packageToPush); } if (tags.Count != 1) { errorsAndInfos.Errors.Add(string.Format(Properties.Resources.RemotePackageContainsSeveralTags, tags)); return(packageToPush); } var tag = tags[0]; errorsAndInfos.Infos.Add(string.Format(Properties.Resources.CheckingIfThereAreChangedBinaries, headTipIdSha, tag)); var listerErrorsAndInfos = new ErrorsAndInfos(); var changedBinaries = ChangedBinariesLister.ListChangedBinaries(packageId, headTipIdSha, tag, listerErrorsAndInfos); if (listerErrorsAndInfos.AnyErrors()) { errorsAndInfos.Infos.AddRange(listerErrorsAndInfos.Infos); errorsAndInfos.Errors.AddRange(listerErrorsAndInfos.Errors); return(packageToPush); } if (!changedBinaries.Any()) { errorsAndInfos.Infos.Add(string.Format(Properties.Resources.NoBinariesHaveChanged)); return(packageToPush); } } errorsAndInfos.Infos.Add(Properties.Resources.PackageNeedsToBePushed); packageToPush.PackageFileFullName = packageFolderWithBinaries.FullName + @"\" + packageId + "." + latestLocalPackageVersion + ".nupkg"; packageToPush.Id = packageId; packageToPush.Version = latestLocalPackageVersion?.ToString(); if (File.Exists(packageToPush.PackageFileFullName)) { return(packageToPush); } errorsAndInfos.Errors.Add(string.Format(Properties.Resources.FileNotFound, packageToPush.PackageFileFullName)); return(packageToPush); }