public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package)
{
#region Preconditions
if (package == null) throw new ArgumentNullException(nameof(package));
#endregion
var key = id.ToString() + "/" + version.ToString();
using (var ms = new MemoryStream())
{
await package.ZipToStreamAsync(ms).ConfigureAwait(false);
var hash = Hash.ComputeSHA256(ms, leaveOpen: true);
var blob = new Blob(ms) {
ContentType = "application/zip"
};
await bucket.PutAsync(key, blob).ConfigureAwait(false);
return hash;
}
}
private void AttemptToGetPackageFromCache(string packageId, SemanticVersion version, string feedId, string cacheDirectory, out IPackage downloaded, out string downloadedTo)
{
downloaded = null;
downloadedTo = null;
Log.VerboseFormat("Checking package cache for package {0} {1}", packageId, version.ToString());
var name = GetNameOfPackage(packageId, version.ToString());
fileSystem.EnsureDirectoryExists(cacheDirectory);
var files = fileSystem.EnumerateFilesRecursively(cacheDirectory, name + "*.nupkg");
foreach (var file in files)
{
var package = ReadPackageFile(file);
if (package == null)
continue;
if (!string.Equals(package.Id, packageId, StringComparison.OrdinalIgnoreCase) || !string.Equals(package.Version.ToString(), version.ToString(), StringComparison.OrdinalIgnoreCase))
continue;
downloaded = package;
downloadedTo = file;
}
}
public void GeneralCtorTest()
{
SemanticVersion v = new SemanticVersion(0, 2, 1);
Assert.Equal("0.2.1", v.ToString());
Assert.Equal("0.2.1", v.ToString("C"));
Assert.Equal("0.2.1", v.ToString("G"));
}
public void FullCtorTest()
{
PreRelease pre = new PreRelease(PreReleaseStage.BETA, 5);
SemanticVersion v = new SemanticVersion(0, 2, 1, pre, 1000);
Assert.Equal("0.2.1-BETA.5+1000", v.ToString());
Assert.Equal("0.2.1-BETA.5", v.ToString("C"));
Assert.Equal("0.2.1", v.ToString("G"));
}
public void ComparableCtorTest()
{
PreRelease pre = new PreRelease(PreReleaseStage.ALPHA);
SemanticVersion v = new SemanticVersion(0, 2, 1, pre);
Assert.Equal("0.2.1-ALPHA", v.ToString(""));
Assert.Equal("0.2.1-ALPHA", v.ToString("C"));
Assert.Equal("0.2.1", v.ToString("G"));
}
public void DownloadPackage(HttpContextBase context)
{
RouteData routeData = GetRouteData(context);
// Get the package file name from the route
string packageId = routeData.GetRequiredString("packageId");
var version = new SemanticVersion(routeData.GetRequiredString("version"));
string filename = packageId + "." + version.ToString() + ".nupkg";
IPackage requestedPackage = _azureRepository.FindPackage(packageId, version);
if (requestedPackage != null)
{
CloudBlockBlob blob = _azureRepository.GetBlob(requestedPackage);
MemoryStream ms = new MemoryStream();
blob.DownloadToStream(ms);
context.Response.Clear();
context.Response.AddHeader("content-disposition", String.Format("attachment; filename={0}", filename));
context.Response.ContentType = "application/octet-stream";
context.Response.BinaryWrite(ms.ToArray());
context.Response.End();
}
else
{
// Package not found
WritePackageNotFound(context, packageId, version);
}
}
public void WillReturnConflictIfAPackageWithTheIdAndSemanticVersionAlreadyExists()
{
var version = new SemanticVersion("1.0.42");
var nuGetPackage = new Mock<IPackage>();
nuGetPackage.Setup(x => x.Id).Returns("theId");
nuGetPackage.Setup(x => x.Version).Returns(version);
var user = new User();
var packageRegistration = new PackageRegistration
{
Packages = new List<Package> { new Package { Version = version.ToString() } },
Owners = new List<User> { user }
};
var packageSvc = new Mock<IPackageService>();
packageSvc.Setup(x => x.FindPackageRegistrationById(It.IsAny<string>())).Returns(packageRegistration);
var userSvc = new Mock<IUserService>();
userSvc.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(user);
var controller = CreateController(userSvc: userSvc, packageSvc: packageSvc, packageFromInputStream: nuGetPackage.Object);
// Act
var result = controller.CreatePackagePut(Guid.NewGuid().ToString());
// Assert
Assert.IsType<HttpStatusCodeWithBodyResult>(result);
var statusCodeResult = (HttpStatusCodeWithBodyResult)result;
Assert.Equal(409, statusCodeResult.StatusCode);
Assert.Equal(String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"), statusCodeResult.StatusDescription);
}
private IEnumerable<NuDeployPackageInfo> GetAllPackages()
{
IEnumerable<PackageInfo> installedPackages = this.packageConfigurationAccessor.GetInstalledPackages();
foreach (PackageInfo package in installedPackages)
{
string packagePrefix = string.Format("{0}.", package.Id);
var packageDirectories =
this.filesystemAccessor.GetSubDirectories(this.applicationInformation.StartupFolder).Where(
dir => dir.Name.StartsWith(packagePrefix, StringComparison.OrdinalIgnoreCase));
foreach (DirectoryInfo packageDirectory in packageDirectories)
{
string packageVersionString = packageDirectory.Name.Replace(string.Format("{0}.", package.Id), string.Empty);
var packageVersion = new SemanticVersion(packageVersionString);
var isInstalled = packageVersion.ToString().Equals(package.Version);
yield return new NuDeployPackageInfo
{
Id = package.Id,
Version = packageVersion,
Folder = packageDirectory.FullName,
IsInstalled = isInstalled
};
}
}
}
public async Task<Package> GetAsync(long id, SemanticVersion version, Hash hash)
{
var key = prefix + id.ToString() + "/" + version.ToString();
var ms = new MemoryStream();
using (var blob = await bucket.GetAsync(key))
{
using (var data = blob.Open())
{
await data.CopyToAsync(ms).ConfigureAwait(false);
}
}
ms.Position = 0;
var secret = SecretKey.Derive(password, hash.Data);
var protector = new AesProtector(secret); // dispose?
var stream = protector.DecryptStream(ms);
#region Verify the hash
var computedHash = Hash.ComputeSHA256(stream, true);
if (computedHash != hash)
{
throw new IntegrityException(hash.Data, computedHash.Data);
}
#endregion
return ZipPackage.FromStream(stream, false);
}
public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package)
{
var key = prefix + id.ToString() + "/" + version.ToString();
using (var ms = new MemoryStream())
{
await package.ZipToStreamAsync(ms).ConfigureAwait(false);
ms.Position = 0;
var hash = Hash.ComputeSHA256(ms, leaveOpen: true);
var secret = SecretKey.Derive(password, hash.Data);
using (var protector = new AesProtector(secret))
{
using (var packageStream = protector.EncryptStream(ms))
{
var blob = new Blob(packageStream) {
ContentType = "application/zip"
};
await bucket.PutAsync(key, blob).ConfigureAwait(false);
}
}
return hash;
}
}
public static void MarkFixed(this Stack stack, SemanticVersion version = null)
{
stack.Status = StackStatus.Fixed;
stack.DateFixed = SystemClock.UtcNow;
stack.FixedInVersion = version?.ToString();
stack.SnoozeUntilUtc = null;
}
public void BumpPatchVersion()
{
var semver = new SemanticVersion(Version);
var newVer = new SemanticVersion(semver.Major, semver.Minor, semver.Patch+1,build:null, preRelease: null);
Version = FileVersion = newVer.ToString();
}
static string GetVersion(SemanticVersion version)
{
if (version != null) {
return version.ToString();
}
return null;
}
public virtual string GetPackageDirectory(string packageId, SemanticVersion version)
{
string directory = packageId;
if (_useSideBySidePaths)
{
directory = Path.Combine(directory, version.ToString());
}
return directory;
}
void INuGet.SavePackageVersion(string path, Version version)
{
var manifest = Manifest.ReadFrom(null, false);
var semanticVersion = new SemanticVersion(version);
manifest.Metadata.Version = semanticVersion.ToString();
manifest.Save(null);
}
/// <summary>
/// Checks whether an IPackage exists within a PackageManager. By default, will use the UseSideBySide settings of the DefaultPackagePathProvider the PackageManager is instantiated with.
/// If passed in TRUE for exhaustive, will check both with and without UseSideBySide set.
/// </summary>
/// <param name="packageManager"></param>
/// <param name="packageId"> </param>
/// <param name="version"> </param>
/// <param name="exhaustive"></param>
/// <returns></returns>
public static bool IsPackageInstalled(this PackageManager packageManager, string packageId, SemanticVersion version, bool exhaustive = false)
{
IPackage package = new DataServicePackage
{
Version = version.ToString(),
Id = packageId
};
return(packageManager.IsPackageInstalled(package, exhaustive));
}
public bool IsNewerThan(string versionStrA, string versionStrB)
{
// arrange
ISemanticVersion versionA = new SemanticVersion(versionStrA);
ISemanticVersion versionB = new SemanticVersion(versionStrB);
// assert
Assert.AreEqual(versionA.IsNewerThan(versionB), versionA.IsNewerThan(versionB.ToString()), "The two signatures returned different results.");
return(versionA.IsNewerThan(versionB));
}
public void StringConstructorParsesValuesCorrectly(string version, Version versionValue, string specialValue)
{
// Act
SemanticVersion semanticVersion = new SemanticVersion(version);
// Assert
Assert.Equal(versionValue, semanticVersion.Version);
Assert.Equal(specialValue, semanticVersion.SpecialVersion);
Assert.Equal(version, semanticVersion.ToString());
}
/// <summary>
/// Checks whether an IPackage exists within a PackageManager. By default, will use the UseSideBySide settings of the DefaultPackagePathProvider the PackageManager is instantiated with.
/// If passed in TRUE for exhaustive, will check both with and without UseSideBySide set.
/// </summary>
/// <param name="packageManager"></param>
/// <param name="packageId"> </param>
/// <param name="version"> </param>
/// <param name="exhaustive"></param>
/// <returns></returns>
public static bool IsPackageInstalled(this PackageManager packageManager, string packageId, SemanticVersion version, bool exhaustive = false)
{
IPackage package = new DataServicePackage
{
Version = version.ToString(),
Id = packageId
};
return packageManager.IsPackageInstalled(package, exhaustive);
}
public void StringConstructorParsesValuesCorrectly(string version, Version versionValue, string specialValue)
{
// Act
SemanticVersion semanticVersion = new SemanticVersion(version);
// Assert
Assert.Equal(versionValue, semanticVersion.Version);
Assert.Equal(specialValue, semanticVersion.SpecialVersion);
Assert.Equal(version, semanticVersion.ToString());
}
public void Serialisable(string versionStr)
{
// act
string json = JsonConvert.SerializeObject(new SemanticVersion(versionStr));
SemanticVersion after = JsonConvert.DeserializeObject <SemanticVersion>(json);
// assert
Assert.IsNotNull(after, "The semantic version after deserialisation is unexpectedly null.");
Assert.AreEqual(versionStr, after.ToString(), "The semantic version after deserialisation doesn't match the input version.");
}
public void WriteVersion(SemanticVersion nextVersion)
{
var doc = ReadProject(ProjectFile);
var versionElement = SelectVersionNode(doc);
versionElement.InnerText = nextVersion.ToString();
doc.Save(ProjectFile);
}
public static NuGetVersion SafeToNuGetVer(SemanticVersion semanticVersion)
{
if (semanticVersion == null)
{
return(null);
}
// Parse using the original version string to support non-normalized scenarios.
return(NuGetVersion.Parse(semanticVersion.ToString()));
}
public void AddPackageReference(string packageId, SemanticVersion version, bool ignoreDependencies, bool allowPrereleaseVersions)
{
string key = packageId + version.ToString();
if (addPackageReferenceCallbacks.ContainsKey(key))
{
Action callback = addPackageReferenceCallbacks [key];
callback();
}
}
public void CallToString()
{
// Setup
var version1 = new SemanticVersion(1, 2, 3, "rc3");
// Execute
var result = version1.ToString();
// Assert
Assert.AreEqual("1.2.3-rc3", result);
}
public SemanticVersionToken(
int position,
int consumedLength,
SemanticVersion semanticVersion)
: base(
position,
consumedLength,
semanticVersion.ToString())
{
this.SemanticVersion = semanticVersion;
}
public void CallToString()
{
// Setup
var version1 = new SemanticVersion(1, 2, 3, "rc3");
// Execute
var result = version1.ToString();
// Assert
Assert.AreEqual("1.2.3-rc3", result);
}
public static Version ToVersion(this SemanticVersion semanticVersion)
{
string versionString = semanticVersion.ToString();
if (!String.IsNullOrEmpty(semanticVersion.SpecialVersion))
{
// Remove special version from string (-1 for the "-" added before the version)
versionString = versionString.Substring(0, versionString.Length - semanticVersion.SpecialVersion.Length - 1);
}
return(new Version(versionString));
}
IEnumerable <IGrouping <string, string> > OverrideWithInputs(IEnumerable <IGrouping <string, string> > parameters)
{
var overrides = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (Configuration != null)
{
overrides.Add("Configuration", Configuration);
}
if (Incremental)
{
overrides.Add("Incremental", "True");
}
overrides.Add("OpenWrap-CurrentBuildVersion", _generatedVersion.ToString());
if (_sharedAssemblyInfoFile != null)
{
overrides.Add("OpenWrap-SharedAssemblyInfoFile", _sharedAssemblyInfoFile.Path.FullPath);
}
return(overrides.GroupBy(x => x.Key, x => x.Value).Concat(_wildcards.Concat(parameters).Where(param => !overrides.ContainsKey(param.Key))));
}
/// <summary>
/// Returns the latest stable version string for the given package.
/// </summary>
/// <param name="packageId"></param>
/// <returns></returns>
public static string GetLatestStableVersion(string packageId)
{
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository(sourceUrl) as IPackageRepository;
List <IPackage> packages = repo.FindPackagesById(packageId).ToList();
packages = packages.Where(item => item.IsListed()).ToList();
packages = packages.Where(item => item.IsReleaseVersion()).ToList();
SemanticVersion version = packages.Max(item => item.Version);
return(version.ToString());
}
public bool IsBetween(string versionStr, string lowerStr, string upperStr)
{
// arrange
ISemanticVersion lower = new SemanticVersion(lowerStr);
ISemanticVersion upper = new SemanticVersion(upperStr);
ISemanticVersion version = new SemanticVersion(versionStr);
// assert
Assert.AreEqual(version.IsBetween(lower, upper), version.IsBetween(lower.ToString(), upper.ToString()), "The two signatures returned different results.");
return(version.IsBetween(lower, upper));
}
public void ParseSemanticVersionStrict(string versionString)
{
// Act
SemanticVersion semVer = null;
SemanticVersion.TryParseStrict(versionString, out semVer);
// Assert
Assert.Equal <string>(versionString, semVer.ToFullString());
Assert.Equal <string>(semVer.ToNormalizedString(), semVer.ToString());
}
private PackageFromBuiltInFeedResource TryFindPackage(string packageId, SemanticVersion version)
{
try
{
return(repository.BuiltInPackageRepository.GetPackage(packageId, version.ToString()));
}
catch (OctopusResourceNotFoundException)
{
return(null);
}
}
public string Constructor_FromAssemblyVersion(int major, int minor, int patch)
{
// act
ISemanticVersion version = new SemanticVersion(new Version(major, minor, patch));
// assert
Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
return(version.ToString());
}
public static SemanticVersion GetLimitingMajor(this SemanticVersion semanticVersion)
{
// do not modify the test below, due to SemanticVersion.NormalizeVersionValue() in SemanticVersion ctor
if (semanticVersion.ToString().Count(c => c == '.') > 2)
{
return(new SemanticVersion(semanticVersion.Version.Major + 1, 0, 0, 0));
}
else
{
return(new SemanticVersion(semanticVersion.Version.Major + 1, 0, 0, null));
}
}
public override string ToString()
{
return("ControlResponsePoller{" +
"controlSessionId=" + controlSessionId +
", correlationId=" + correlationId +
", relevantId=" + relevantId +
", code=" + code +
", version=" + SemanticVersion.ToString(version) +
", errorMessage='" + errorMessage + '\'' +
", isPollComplete=" + isPollComplete +
'}');
}
public void ConstructSemanticVersionWithParts()
{
// Execute
var version = new SemanticVersion(1, 2, 3, "alpha");
// Assert
Assert.AreEqual(1, version.Major);
Assert.AreEqual(2, version.Minor);
Assert.AreEqual(3, version.Patch);
Assert.AreEqual("alpha", version.Release);
Assert.AreEqual("1.2.3-alpha", version.ToString());
}
public void ConstructSemanticVersionWithNoRelease()
{
// Execute
var version = new SemanticVersion("2.1.0");
// Assert
Assert.AreEqual(2, version.Major);
Assert.AreEqual(1, version.Minor);
Assert.AreEqual(0, version.Patch);
Assert.AreEqual("", version.Release);
Assert.AreEqual("2.1.0", version.ToString());
}
/// <summary>
/// Returns the normalized version identity. This does not contain metadata since
/// it is not part of the actual package identity.
/// </summary>
public static string ToIdentityString(this SemanticVersion version)
{
var formatter = new VersionFormatter();
var format = "V";
if (version.IsPrerelease)
{
format += "-R";
}
return(version.ToString(format, formatter));
}
public void ConstructSemanticversionWithPartsAndNullRelease()
{
// Execute
var version = new SemanticVersion(1, 2, 3, a_release: null);
// Assert
Assert.AreEqual(1, version.Major);
Assert.AreEqual(2, version.Minor);
Assert.AreEqual(3, version.Patch);
Assert.AreEqual("", version.Release);
Assert.AreEqual("1.2.3", version.ToString());
}
static PackageContent GenerateVersionFile(SemanticVersion generatedVersion)
{
var versionStream = generatedVersion.ToString().ToUTF8Stream();
return(new PackageContent
{
FileName = "version",
RelativePath = ".",
Stream = versionStream.ResetOnRead(),
Size = versionStream.Length
});
}
public string Constructor_FromParts(int major, int minor, int patch, string tag)
{
// act
ISemanticVersion version = new SemanticVersion(major, minor, patch, tag);
// assert
Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
Assert.AreEqual(string.IsNullOrWhiteSpace(tag) ? null : tag.Trim(), version.Build, "The tag doesn't match the given value.");
return(version.ToString());
}
/// <summary>
/// Find the package files (.nupkg or .nuspec).
/// </summary>
/// <param name="packageId"></param>
/// <param name="version"></param>
/// <returns></returns>
private IEnumerable <string> GetPackageLookupPaths(string packageId, SemanticVersion version)
{
// Files created by the path resolver. This would take into account the non-side-by-side scenario
// and we do not need to match this for id and version.
//var packageFileName = packageId + version + Constant.PackageExtension;
var packageFileName = FileUtility.MakePackageFileName(false, packageId, version.ToString(), NuGetConstant.PackageExtension);
// var packageFileName = PathResolver.GetPackageFileName(packageId, version);
var manifestFileName = Path.ChangeExtension(packageFileName, NuGetConstant.ManifestExtension);
var filesMatchingFullName = GetPackageFiles(packageFileName).Concat(GetPackageFiles(manifestFileName));
if (version.Version.Revision < 1)
{
// If the build or revision number is not set, we need to look for combinations of the format
// * Foo.1.2.nupkg
// * Foo.1.2.3.nupkg
// * Foo.1.2.0.nupkg
// * Foo.1.2.0.0.nupkg
// To achieve this, we would look for files named 1.2*.nupkg if both build and revision are 0 and
// 1.2.3*.nupkg if only the revision is set to 0.
string partialName = version.Version.Build < 1 ?
String.Join(".", packageId, version.Version.Major, version.Version.Minor) :
String.Join(".", packageId, version.Version.Major, version.Version.Minor, version.Version.Build);
string partialManifestName = partialName + "*" + NuGetConstant.ManifestExtension;
partialName += "*" + NuGetConstant.PackageExtension;
// Partial names would result is gathering package with matching major and minor but different build and revision.
// Attempt to match the version in the path to the version we're interested in.
var partialNameMatches = GetPackageFiles(partialName).Where(path => FileNameMatchesPattern(packageId, version, path));
var partialManifestNameMatches = GetPackageFiles(partialManifestName).Where(
path => FileNameMatchesPattern(packageId, version, path));
filesMatchingFullName = filesMatchingFullName.Concat(partialNameMatches).Concat(partialManifestNameMatches);
}
// cannot find matching files, we should try to search for just packageid.nupkg
if (filesMatchingFullName.Count() == 0)
{
// exclude version
var packageWithoutVersionName = FileUtility.MakePackageFileName(true, packageId, null, NuGetConstant.PackageExtension);
var packageWithoutVersionManifest = Path.ChangeExtension(packageWithoutVersionName, NuGetConstant.ManifestExtension);
return(GetPackageFiles(packageWithoutVersionName).Concat(GetPackageFiles(packageWithoutVersionManifest)));
}
return(filesMatchingFullName);
}
public void WriteIntegrationParameters(SemanticVersion semanticVersion, IEnumerable <IBuildServer> applicableBuildServers)
{
foreach (var buildServer in applicableBuildServers)
{
logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));
logger.LogInfo(buildServer.GenerateSetVersionMessage(semanticVersion.ToString()));
logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));
foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(semanticVersion, buildServer))
{
logger.LogInfo(buildParameter);
}
}
}
public bool IsPackageInstalled(Project project, string packageId, SemanticVersion version)
{
NuGetVersion nugetVersion;
if (NuGetVersion.TryParse(version.ToString(), out nugetVersion))
{
return(IsPackageInstalled(project, packageId, nugetVersion));
}
else
{
throw new ArgumentException(VsResources.InvalidNuGetVersionString, nameof(version));
}
}
public void WriteIntegrationParameters(SemanticVersion semanticVersion, IEnumerable<IBuildServer> applicableBuildServers)
{
foreach (var buildServer in applicableBuildServers)
{
logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name));
logger.LogInfo(buildServer.GenerateSetVersionMessage(semanticVersion.ToString()));
logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name));
foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(semanticVersion, buildServer))
{
logger.LogInfo(buildParameter);
}
}
}
// private methods
private ConnectionDescription CreateConnectionDescription(SemanticVersion serverVersion)
{
var clusterId = new ClusterId(1);
var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017));
var connectionId = new ConnectionId(serverId, 1);
var isMasterResult = new IsMasterResult(new BsonDocument());
var buildInfoResult = new BuildInfoResult(new BsonDocument
{
{ "version", serverVersion.ToString() }
});
return(new ConnectionDescription(connectionId, isMasterResult, buildInfoResult));
}
public string Constructor_FromParts(int major, int minor, int patch, string prerelease, string build)
{
// act
ISemanticVersion version = new SemanticVersion(major, minor, patch, prerelease, build);
// assert
Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value.");
Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value.");
Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value.");
Assert.AreEqual(string.IsNullOrWhiteSpace(prerelease) ? null : prerelease.Trim(), version.PrereleaseTag, "The prerelease tag doesn't match the given value.");
Assert.AreEqual(string.IsNullOrWhiteSpace(build) ? null : build.Trim(), version.BuildMetadata, "The build metadata doesn't match the given value.");
return(version.ToString());
}
public void Save(SemanticVersion version, string name, DllReference parentAssembly)
{
var parser = new FileIniDataParser();
var versionsFileData = new IniData();
versionsFileData.Sections.AddSection("Dependency");
versionsFileData.Sections["Dependency"].AddKey("version", version.ToString());
versionsFileData.Sections["Dependency"].AddKey("name", name);
if(!Directory.Exists("cache"))
Directory.CreateDirectory("cache");
parser.WriteFile(@"cache\" + parentAssembly.Id.Item1 + _sectionSeparator + parentAssembly.Id.Item2 + _sectionSeparator + name + ".ini", versionsFileData);
}
public void Save()
{
var id = "TestId";
var version = new SemanticVersion("0.1.0");
var authors = new string[] { "Alice", "Bob" };
var manifest = new Manifest(new ManifestMetadata
{
Id = id,
Version = version,
Authors = authors
});
using (var mem = new MemoryStream())
{
manifest.Save(mem);
mem.Position = 0;
var xdoc = XDocument.Load(mem);
var ns = xdoc.Root.GetDefaultNamespace();
var xElemPackage = xdoc.Root;
Assert.Equal("package", xElemPackage.Name.LocalName);
Assert.Equal(1, xElemPackage.Elements().Count());
var xElemMetadata = xElemPackage.Elements().Single();
Assert.Equal("metadata", xElemMetadata.Name.LocalName);
Assert.Equal(5, xElemMetadata.Elements().Count());
var xElemId = xElemMetadata.Element(ns + "id");
Assert.NotNull(xElemId);
Assert.Equal(id, xElemId.Value);
var xElemVersion = xElemMetadata.Element(ns + "version");
Assert.NotNull(xElemVersion);
Assert.Equal(version.ToString(), xElemVersion.Value);
var xElemRequireLicense = xElemMetadata.Element(ns + "requireLicenseAcceptance");
Assert.NotNull(xElemRequireLicense);
Assert.Equal("false", xElemRequireLicense.Value);
var xElemAuthors = xElemMetadata.Element(ns + "authors");
Assert.NotNull(xElemAuthors);
Assert.Equal(string.Join(",", authors), xElemAuthors.Value);
var xElemOwners = xElemMetadata.Element(ns + "owners");
Assert.NotNull(xElemOwners);
Assert.Equal(string.Join(",", authors), xElemOwners.Value);
}
}
public void ComplexVersionByStringDecompositionResultEqualsInput()
{
const string preRelease = "alpha.2.abc.f-d";
const string build = "svn.a-4.12342";
var version = new SemanticVersion(1, 2, 3, preRelease, build);
Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc.f-d+svn.a-4.12342"));
version = new SemanticVersion(1, 2, 3, preRelease, null);
Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc.f-d"));
version = new SemanticVersion(1, 2, 3, null, build);
Assert.That(version.ToString(), Is.EqualTo("1.2.3+svn.a-4.12342"));
}
public override bool Exists(string packageId, SemanticVersion version)
{
if (version != null)
{
// optimization: if we find the sub-directory with the name "id.version", consider it exists
string folderPath = packageId + "." + version.ToString();
if (FileSystem.DirectoryExists(folderPath))
{
return true;
}
}
return FindPackage(packageId, version) != null;
}
public void ValidateInformationalVersionBuilder(BranchType branchType, string branchName, string sha, int major, int minor, int patch,
string tag, int? suffix, string versionString)
{
var semanticVersion = new SemanticVersion
{
Major = major,
Minor = minor,
Patch = patch,
PreReleaseTag = tag,
BuildMetaData = new SemanticVersionBuildMetaData(suffix, branchName, new ReleaseDate{ CommitSha = sha }),
};
var informationalVersion = semanticVersion.ToString("i");
Assert.AreEqual(versionString, informationalVersion);
}
public void ValidateInformationalVersionBuilder(string branchName, string sha, int major, int minor, int patch,
string tag, int? suffix, string versionString)
{
var semanticVersion = new SemanticVersion
{
Major = major,
Minor = minor,
Patch = patch,
PreReleaseTag = tag,
BuildMetaData = new SemanticVersionBuildMetaData(suffix, branchName,sha,DateTimeOffset.MinValue),
};
var informationalVersion = semanticVersion.ToString("i");
Assert.AreEqual(versionString, informationalVersion);
}
private void AttemptToDownload(string packageId, SemanticVersion version, Uri feedUri, string cacheDirectory, out string downloadedTo, out IPackage downloaded)
{
Console.WriteLine("Downloading NuGet package {0} {1} from feed: '{2}'", packageId, version, feedUri);
Log.VerboseFormat("Downloaded package will be stored in: '{0}'", cacheDirectory);
fileSystem.EnsureDirectoryExists(cacheDirectory);
fileSystem.EnsureDiskHasEnoughFreeSpace(cacheDirectory);
downloaded = null;
downloadedTo = null;
Exception downloadException = null;
for (var i = 1; i <= NumberOfTimesToAttemptToDownloadPackage; i++)
{
try
{
AttemptToFindAndDownloadPackage(i, packageId, version.ToString(), feedUri.ToString(), cacheDirectory,
out downloaded, out downloadedTo);
break;
}
catch (Exception dataException)
{
Log.VerboseFormat("Attempt {0} of {1}: Unable to download package: {2}", i,
NumberOfTimesToAttemptToDownloadPackage, dataException.Message);
downloadException = dataException;
Thread.Sleep(i*1000);
}
}
if (downloaded == null || downloadedTo == null)
{
if (downloadException != null)
{
Log.ErrorFormat("Unable to download package: {0}", downloadException.Message);
}
throw new Exception(
"The package could not be downloaded from NuGet. If you are getting a package verification error, try switching to a Windows File Share package repository to see if that helps.");
}
if (downloaded.Version != version)
{
throw new Exception(string.Format(
"Octopus requested version {0} of {1}, but the NuGet server returned a package with version {2}",
version, packageId, downloaded.Version));
}
CheckWhetherThePackageHasDependencies(downloaded);
}
public void ComplexVersionDecompositionResultEqualsInput()
{
var preRelease = new [] {"alpha", "2", "abc"};
var build = new[] { "svn", "12342" };
Contract.Assert(Contract.ForAll(preRelease, part => !String.IsNullOrEmpty(part) && part.All(Char.IsLetterOrDigit)));
Contract.Assert(Contract.ForAll(build, part => !String.IsNullOrEmpty(part) && part.All(Char.IsLetterOrDigit)));
var version = new SemanticVersion(1, 2, 3, preRelease, build);
Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc+svn.12342"));
version = new SemanticVersion(1, 2, 3, preRelease, null);
Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc"));
version = new SemanticVersion(1, 2, 3, null, build);
Assert.That(version.ToString(), Is.EqualTo("1.2.3+svn.12342"));
}
public static Dictionary<string, string> GetVariablesFor(
SemanticVersion semanticVersion,
AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch,
bool addNumberOfCommitsSinceTagOnMasterBranchToFileVersion = true)
{
var bmd = semanticVersion.BuildMetaData;
var formatter = bmd.Branch == "develop" ? new CiFeedFormatter() : null;
var assemblyMetaData = AssemblyVersionsGenerator.Process(
semanticVersion, assemblyVersioningScheme, addNumberOfCommitsSinceTagOnMasterBranchToFileVersion);
var variables = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase)
{
{Major, semanticVersion.Major.ToString()},
{Minor, semanticVersion.Minor.ToString()},
{Patch, semanticVersion.Patch.ToString()},
{PreReleaseTag, semanticVersion.PreReleaseTag},
{PreReleaseTagWithDash, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null},
{BuildMetaData, bmd},
{FullBuildMetaData, bmd.ToString("f")},
{MajorMinorPatch, string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch)},
{SemVer, semanticVersion.ToString(null, formatter)},
{LegacySemVer, semanticVersion.ToString("l", formatter)},
{LegacySemVerPadded, semanticVersion.ToString("lp", formatter)},
{AssemblySemVer, semanticVersion.ToString("j") + ".0"},
{FullSemVer, semanticVersion.ToString("f", formatter)},
{InformationalVersion, semanticVersion.ToString("i", formatter)},
{ClassicVersion, string.Format("{0}.{1}", semanticVersion.ToString("j"), (bmd.CommitsSinceTag ?? 0))},
{ClassicVersionWithTag, string.Format("{0}.{1}{2}", semanticVersion.ToString("j"),
bmd.CommitsSinceTag ?? 0,
semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null)},
{BranchName, bmd.Branch},
{Sha, bmd.Sha},
{AssemblyVersion, assemblyMetaData.Version},
{AssemblyFileVersion, assemblyMetaData.FileVersion},
{OriginalRelease, string.Format("{0}.{1}",
bmd.ReleaseDate.OriginalCommitSha,
bmd.ReleaseDate.OriginalDate.UtcDateTime.ToString("u"))},
};
return variables;
}
public async Task<IPackage> GetAsync(long id, SemanticVersion version)
{
var key = id.ToString() + "/" + version.ToString();
var ms = new MemoryStream();
using (var blob = await bucket.GetAsync(key).ConfigureAwait(false))
{
using (var channel = blob.Open())
{
await channel.CopyToAsync(ms).ConfigureAwait(false);
}
}
ms.Position = 1;
return ZipPackage.FromStream(ms, stripFirstLevel: false);
}
public static Dictionary<string, string> GetVariablesFor(
SemanticVersion semanticVersion)
{
var bmd = semanticVersion.BuildMetaData;
var formatter = bmd.Branch == "develop" ? new CiFeedFormatter() : null;
var variables = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase)
{
{Major, semanticVersion.Major.ToString()},
{Minor, semanticVersion.Minor.ToString()},
{Patch, semanticVersion.Patch.ToString()},
{PreReleaseTag, semanticVersion.PreReleaseTag},
{PreReleaseTagWithDash, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null},
{BuildMetaData, bmd},
{FullBuildMetaData, bmd.ToString("f")},
{MajorMinorPatch, string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch)},
{SemVer, semanticVersion.ToString(null, formatter)},
{LegacySemVer, semanticVersion.ToString("l", formatter)},
{LegacySemVerPadded, semanticVersion.ToString("lp", formatter)},
{AssemblySemVer, semanticVersion.ToString("j") + ".0"},
{FullSemVer, semanticVersion.ToString("f", formatter)},
{InformationalVersion, semanticVersion.ToString("i", formatter)},
{ClassicVersion, string.Format("{0}.{1}", semanticVersion.ToString("j"), (bmd.CommitsSinceTag ?? 0))},
{ClassicVersionWithTag, string.Format("{0}.{1}{2}", semanticVersion.ToString("j"),
bmd.CommitsSinceTag ?? 0,
semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null)},
{BranchName, bmd.Branch},
{Sha, bmd.Sha},
{OriginalRelease, string.Format("{0}.{1}",
bmd.ReleaseDate.OriginalCommitSha,
bmd.ReleaseDate.OriginalDate.UtcDateTime.ToString("u"))},
};
// Use ToLower() to fix a bug where Beta and beta are different in NuGet
variables[NuGetVersionV2] = variables[LegacySemVerPadded].ToLower();
//variables[NuGetVersionV3] = variables[LegacySemVerPadded].ToLower(); // TODO: when v3 is released, determine what to use
variables[NuGetVersion] = variables[NuGetVersionV2];
return variables;
}
public void ToStringJTests()
{
Assert.AreEqual("1.2.3", SemanticVersion.Parse("1.2.3", null).ToString("j"));
Assert.AreEqual("1.2.3", SemanticVersion.Parse("1.2.3-beta.4", null).ToString("j"));
var fullSemVer = new SemanticVersion
{
Major = 1,
Minor = 2,
Patch = 3,
PreReleaseTag = new SemanticVersionPreReleaseTag("beta", 4),
BuildMetaData = new SemanticVersionBuildMetaData
{
Sha = "theSha",
Branch = "TheBranch",
CommitsSinceTag = 5,
OtherMetaData = "TheOtherMetaData"
}
};
Assert.AreEqual("1.2.3", fullSemVer.ToString("j"));
}
