public static bool IsPreviewVersion(string version)
{
var semVer = SemVersion.Parse(version);
VersionTag pre = VersionTag.Parse(semVer.Prerelease);
return(PackageLifecyclePhase.IsPreviewVersion(semVer, pre));
}
/**
* Can't promote if it's a release or RC
* Can promote -preview, -pre (unless it is the first one, but that is verified somewhere else) and -exp
* Error in Promotion
* Only warn when in CI
*/
private void ValidateVersionAbilityToPromote(SemVersion packageVersionNumber, VersionTag versionTag, ManifestData manifestData)
{
// Make this check only in promotion, to avoid network calls
if (Context.PackageVersionExistsOnProduction)
{
AddPromotionConditionalError("Version " + Context.ProjectPackageInfo.version + " of this package already exists in production.");
}
var message = String.Empty;
if (PackageLifecyclePhase.IsReleasedVersion(packageVersionNumber, versionTag) ||
PackageLifecyclePhase.IsRCForThisEditor(manifestData.name, Context))
{
message = $"Automated promotion of Release or Release Candidate packages is not allowed. Release Management are the only ones that can promote Release and Release Candidate packages to production, if you need this to happen, please go to #devs-pkg-promotion. {ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "a-release-package-must-be-manually-promoted-by-release-management")}";
}
else
{
// We send a message if this is the first version of the package being promoted
if (!Context.PackageExistsOnProduction)
{
message = $"{Context.PublishPackageInfo.name} has never been promoted to production before. Please contact Release Management through slack in #devs-pkg-promotion to promote the first version of your package before trying to use this automated pipeline. {ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "the-very-first-version-of-a-package-must-be-promoted-by-release-management")}";
}
}
if (message != String.Empty)
{
AddPromotionConditionalError(message);
}
}
private void ValidateDependenciesLifecyclePhase(Dictionary <string, string> dependencies)
{
// No dependencies, exit early
if (!dependencies.Any())
{
return;
}
// Extract the current track, since otherwise we'd be potentially parsing the version
// multiple times
var currentTrack = PackageLifecyclePhase.GetLifecyclePhaseOrRelation(Context.ProjectPackageInfo.version, Context.ProjectPackageInfo.name, Context);
var supportedVersions = PackageLifecyclePhase.GetPhaseSupportedVersions(currentTrack);
// Check each dependency against supported versions
foreach (var dependency in dependencies)
{
// Skip invalid dependencies from this check
SemVersion depVersion;
if (!SemVersion.TryParse(dependency.Value, out depVersion))
{
continue;
}
LifecyclePhase dependencyTrack = PackageLifecyclePhase.GetLifecyclePhaseOrRelation(dependency.Value.ToLower(), dependency.Key.ToLower(), Context);
var depId = Utilities.CreatePackageId(dependency.Key, dependency.Value);
if (!supportedVersions.HasFlag(dependencyTrack))
{
AddError($"Package {Context.ProjectPackageInfo.Id} depends on package {depId} which is in an invalid track for release purposes. {currentTrack} versions can only depend on {supportedVersions.ToString()} versions. {ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "package-depends-on-a-package-which-is-in-an-invalid-track-for-release-purposes")}");
}
}
}
/// <summary>
/// If the package we are evaluating is trying to release a -preview, then this is against lifecycle v1 rules
/// Otherwise, we evaluate against lifecycle v2 rules for all packages
/// </summary>
/// <param name="version">Version of the package we are evaluating</param>
/// <returns></returns>
public static double EvaluateLifecycle(string version)
{
return(PackageLifecyclePhase.GetLifecyclePhase(version.ToLower()) == LifecyclePhase.Preview ? 1.0 : 2.0);
}
private void PreReleaseChecks(ManifestData currentManifest)
{
string errorMsg = String.Empty;
if (Context.AllVersions != null)
{
SemVersion pkgVersion = SemVersion.Parse(currentManifest.version);
// Get all versions that match x.y.z (so, any exp, preview, prerelease, etc).
List <SemVersion> relatedVersions = pkgVersion.GetRelatedVersions(Context.AllVersions);
// Get only the related previous versions
SemVersion prevVersion = relatedVersions.Where(v => v <= pkgVersion).ToList().LastOrDefault();
if (prevVersion != null)
{
if (!PackageLifecyclePhase.IsPreReleaseVersion(prevVersion, VersionTag.Parse(prevVersion.Prerelease)))
{
errorMsg = string.Format(
"The previous version of this package ({0}) is not a Pre-Release. By Lifecycle V2 rules, a Pre-Release package can only be promoted automatically to production when the previous version is also a Pre-Release version. {1}",
prevVersion.ToString(),
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"previous-version-of-this-package-is-not-a-pre-release-version"));
}
else
{
SemVersion lastPreVersion = relatedVersions.Where(v =>
{
VersionTag t = VersionTag.Parse(v.Prerelease);
return(PackageLifecyclePhase.IsPreReleaseVersion(v, t));
}).ToList().LastOrDefault();
if (lastPreVersion != null)
{
VersionTag lastTag = VersionTag.Parse(lastPreVersion.Prerelease);
VersionTag pkgTag = VersionTag.Parse(pkgVersion.Prerelease);
if (pkgTag.Iteration <= lastTag.Iteration)
{
errorMsg = string.Format(
"This package iteration ({0}) must be higher than the highest published iteration ({1}). Please update your package version to {2} {3}",
pkgTag.Iteration,
lastTag.Iteration,
string.Format("{0}-{1}.{2}", pkgVersion.VersionOnly(), pkgTag.Tag,
lastTag.Iteration + 1),
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"this-package-iteration-(x)-must-be-higher-than-the-highest-published-iteration-(y)"));
}
}
}
}
else
{
errorMsg = string.Format(
"There is no previous Pre-Release version of this package available. By Lifecycle V2 rules, the first Pre-Release iteration of a new version needs to be approved and promoted by Release Management. Please contact Release Management to promote your package. {0}",
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"previous-version-of-this-package-is-not-a-pre-release-version"));
}
}
if (errorMsg != String.Empty)
{
AddPromotionConditionalError(errorMsg);
}
}
