/// <summary> /// Ensure that a branch exists. /// </summary> /// <param name="m">The monitor.</param> /// <param name="r">The repository.</param> /// <param name="branchName">The name of the branch.</param> /// <param name="noWarnOnCreate">Log as warning if the branch is created.</param> /// <param name="repoDisplayName">Name of the repo displayed in the logs.</param> /// <returns>The Branch.</returns> static Branch DoEnsureBranch(IActivityMonitor m, Repository r, string branchName, bool noWarnOnCreate, string repoDisplayName) { if (String.IsNullOrWhiteSpace(branchName)) { throw new ArgumentNullException(nameof(branchName)); } var b = DoGetBranch(m, r, branchName, logErrorMissingLocalAndRemote: false, repoDisplayName: repoDisplayName); if (b == null) { m.Log(noWarnOnCreate ? Core.LogLevel.Info : Core.LogLevel.Warn, $"Branch '{branchName}' does not exist. Creating local branch.");; b = r.CreateBranch(branchName); } return(b); }
void DumpSources(IActivityMonitor monitor, LogLevel level) { if (Sources != null && Sources.Count > 0) { using (monitor.OpenGroup(level, $"Processed {Sources.Count} source tree(s):")) { for (int i = 0; i < Sources.Count; ++i) { using (monitor.OpenGroup(level, $"Source n°{i}")) { monitor.Log(level, Sources[i].ToString()); } } } } }
public void ApplySettings(IActivityMonitor m) { if (!this.CheckCurrentBranch(m)) { return; } YamlMapping firstMapping = GetFirstMapping(m, true); if (firstMapping == null) { m.Error("First mapping should not return null !"); return; } // We don't use GitLab for public repositories if (GitFolder.IsPublic || GitFolder.KnownGitProvider != KnownGitProvider.GitLab) { if (TextContent != null) { m.Log(LogLevel.Info, "The project is public or the repository is not on GitLab, so we don't use GitLab and the .gitlab-ci.yml is not needed."); Delete(m); } return; } // We use GitLab when the repository is private. YamlMapping codeCakeJob = FindOrCreateYamlElement(m, firstMapping, "codecakebuilder"); SetSequence(codeCakeJob, "tags", new YamlValue("windows")); SetSequence(codeCakeJob, "script", new YamlValue("dotnet run --project CodeCakeBuilder -nointeraction") ); codeCakeJob["artifacts"] = new YamlMapping() { ["paths"] = new YamlSequence() { new YamlValue(@"'**\*.log'"), new YamlValue(@"'**\*.trx'"), new YamlValue(@"'**\Tests\**\TestResult*.xml'"), new YamlValue(@"'**Tests\**\Logs\**\*'"), }, ["when"] = new YamlValue("always"), ["expire_in"] = new YamlValue("6 month") }; CreateOrUpdate(m, YamlMappingToString(m)); }
public void ApplySettings(IActivityMonitor m) { if (!this.CheckCurrentBranch(m)) { return; } YamlMapping firstMapping = GetFirstMapping(m, true); if (firstMapping == null) { return; } var solution = _driver.GetSolution(m, allowInvalidSolution: true); if (solution == null) { return; } // We don't use AppVeyor for private repositories. if (!GitFolder.IsPublic) { if (TextContent != null) { m.Log(LogLevel.Info, "The project is private, so we don't use Appveyor and the Appveyor.yml is not needed."); Delete(m); } return; } // We currently always use AppVeyor when the repository is public. YamlMapping env = FindOrCreateYamlElement(m, firstMapping, "environment"); if (env == null) { return; } var passphrase = _keyStore.GetSecretKey(m, SolutionDriver.CODECAKEBUILDER_SECRET_KEY, false); if (passphrase != null) { var central = KeyVault.DecryptValues(_sharedState.CICDKeyVault, passphrase); if (central.TryGetValue(APPVEYOR_ENCRYPTED_CODECAKEBUILDER_SECRET_KEY, out var appveyorSecure)) { env[SolutionDriver.CODECAKEBUILDER_SECRET_KEY] = CreateKeyValue("secure", appveyorSecure); } else { m.Warn($"Update of {SolutionDriver.CODECAKEBUILDER_SECRET_KEY} encrypted secure key has been skipped: {APPVEYOR_ENCRYPTED_CODECAKEBUILDER_SECRET_KEY} key should be defined in CICDKeyVault."); } } else { m.Info($"Update of {SolutionDriver.CODECAKEBUILDER_SECRET_KEY} encrypted secure skipped."); } // Remove obsolete environment variables definitions. env.Remove("NUGET_API_KEY"); env.Remove("MYGET_RELEASE_API_KEY"); env.Remove("MYGET_PREVIEW_API_KEY"); env.Remove("MYGET_CI_API_KEY"); env.Remove("CK_DB_TEST_MASTER_CONNECTION_STRING"); env.Remove("AZURE_FEED_SIGNATURE_OPENSOURCE_PAT"); env.Remove("AZURE_FEED_PAT"); env.Remove("VSS_NUGET_EXTERNAL_FEED_ENDPOINTS"); if (_solutionSpec.SqlServer != null) { env["SqlServer/MasterConnectionString"] = new YamlValue($"Server=(local)\\SQL{_solutionSpec.SqlServer.ToUpperInvariant()};Database=master;User ID=sa;Password=Password12!"); } // firstMapping.Remove(new YamlValue("init")); if (_solutionSpec.SqlServer != null) { firstMapping["services"] = new YamlValue("mssql" + _solutionSpec.SqlServer.ToLowerInvariant()); } var install = new YamlSequence(); // Temporary: installs the 6.9.0 of npm. if (solution.GeneratedArtifacts.Any(g => g.Artifact.Type.Name == "NPM")) { install.Add(CreateKeyValue("cmd", "npm install -g [email protected]")); install.Add(CreateKeyValue("ps", "Install-Product node 12")); } firstMapping["install"] = install; firstMapping["version"] = new YamlValue("build{build}"); firstMapping["image"] = new YamlValue("Visual Studio 2019"); firstMapping["clone_folder"] = new YamlValue("C:\\CKli-World\\" + GitFolder.SubPath.Path.Replace('/', '\\')); EnsureDefaultBranches(firstMapping); SetSequence(firstMapping, "build_script", new YamlValue("dotnet run --project CodeCakeBuilder -nointeraction")); firstMapping["test"] = new YamlValue("off"); firstMapping["artifacts"] = new YamlSequence() { new YamlMapping() { ["path"] = new YamlValue(@"'**\*.log'"), ["name"] = new YamlValue("Log file") }, new YamlMapping() { ["path"] = new YamlValue(@"'**\*.trx'"), ["name"] = new YamlValue("Visual studio test results file") }, new YamlMapping() { ["path"] = new YamlValue(@"'**\Tests\**\TestResult*.xml'"), ["name"] = new YamlValue("NUnit tests result files") }, new YamlMapping() { ["path"] = new YamlValue(@"'**Tests\**\Logs\**\*'"), ["name"] = new YamlValue("Log files") } }; CreateOrUpdate(m, YamlMappingToString(m)); }
/// <summary> /// Retrieves a <see cref="IStObjAttribute"/> from (potentially multiple) attributes on a type. /// If multiple attributes are defined, <see cref="IStObjAttribute.Requires"/>, <see cref="IStObjAttribute.Children"/>, and <see cref="IStObjAttribute.RequiredBy"/> /// are merged, but if their <see cref="IStObjAttribute.Container"/> are not null or if <see cref="IStObjAttribute.ItemKind"/> is not <see cref="DependentItemKind.Unknown"/> and differ, the /// first one is kept and a log is emitted in the <paramref name="monitor"/>. /// </summary> /// <param name="objectType">The type for which the attribute must be found.</param> /// <param name="monitor">Logger that will receive the warning.</param> /// <param name="multipleContainerLogLevel"><see cref="CK.Core.LogLevel"/> when different containers are detected. By default a warning is emitted.</param> /// <returns> /// Null if no <see cref="IStObjAttribute"/> is set. /// </returns> static internal IStObjAttribute?GetStObjAttributeForExactType(Type objectType, IActivityMonitor monitor, LogLevel multipleContainerLogLevel = LogLevel.Warn) { if (objectType == null) { throw new ArgumentNullException("objectType"); } if (monitor == null) { throw new ArgumentNullException("monitor"); } var a = (IStObjAttribute[])objectType.GetCustomAttributes(typeof(IStObjAttribute), false); if (a.Length == 0) { return(null); } if (a.Length == 1) { return(a[0]); } IList <Type>? requires = null; IList <Type>? requiredBy = null; IList <Type>? children = null; IList <Type>? group = null; DependentItemKindSpec itemKind = DependentItemKindSpec.Unknown; Type? container = null; IStObjAttribute?containerDefiner = null; foreach (IStObjAttribute attr in a) { if (attr.Container != null) { if (container == null) { containerDefiner = attr; container = attr.Container; } else { Debug.Assert(containerDefiner != null && containerDefiner.Container != null); monitor.Log(multipleContainerLogLevel, $"Attribute {attr.GetType().Name} for type {objectType} specifies Container type '{attr.Container.Name}' but attribute {containerDefiner.GetType().Name} specifies Container type '{containerDefiner.Container.Name}'. Container remains '{containerDefiner.Container.Name}'."); } } if (attr.ItemKind != DependentItemKindSpec.Unknown) { if (itemKind != DependentItemKindSpec.Unknown) { monitor.Warn($"ItemKind is already set to '{itemKind}'. Value '{attr.ItemKind}' set by {attr.GetType().Name} is ignored."); } else { itemKind = attr.ItemKind; } } CombineTypes(ref requires, attr.Requires); CombineTypes(ref requiredBy, attr.RequiredBy); CombineTypes(ref children, attr.Children); CombineTypes(ref group, attr.Groups); } var r = new StObjAttribute() { Container = container, ItemKind = itemKind }; if (requires != null) { r.Requires = requires.ToArray(); } if (requiredBy != null) { r.RequiredBy = requiredBy.ToArray(); } if (children != null) { r.Children = children.ToArray(); } if (group != null) { r.Groups = group.ToArray(); } return(r); }