private void CopyFile(string filePath, string destPath)
{
var skeletonPath = Path.GetFullPath("skel");
var destFileName = string.IsNullOrEmpty(destPath) ? filePath : destPath;
var destFileNameFull = Path.GetFullPath(Path.Combine(ProjectRootDir, destFileName));
if (File.Exists(destFileNameFull))
{
Logger.Info("skip {0}", destFileName);
}
else
{
var version = MaxLibVersion.ToString();
var normalizedVersion = MaxLibVersion.ToNormalizedString();
File.Copy(Path.Combine(skeletonPath, filePath), destFileNameFull);
var fileContent = File.ReadAllText(destFileNameFull)
.Replace("$safeprojectname$", SafeProjectName)
.Replace("$guid1$", Guid.NewGuid().ToString())
.Replace("$guid2$", Guid.NewGuid().ToString())
.Replace("$nugetLibVersion$", version)
.Replace("$gaugeprojectfile$", ProjectFilePath)
.Replace("$nugetLibNormalizedVersion$", normalizedVersion);
File.WriteAllText(destFileNameFull, fileContent);
Logger.Info("create {0}", destFileName);
}
}
public void Remove(string id, SemanticVersion version, bool enableDelisting)
{
if (enableDelisting)
{
if (_fileSystem is PhysicalFileSystem physicalFileSystem)
{
var fileName = physicalFileSystem.GetFullPath(
GetPackageFileName(id, version.ToNormalizedString()));
if (File.Exists(fileName))
{
File.SetAttributes(fileName, File.GetAttributes(fileName) | FileAttributes.Hidden);
}
else
{
_logger.Log(
LogLevel.Error,
"Error removing package {0} {1} - could not find package file {2}",
id,
version,
fileName);
}
}
}
else
{
var package = _repository.FindPackage(id, version);
if (package != null)
{
_repository.RemovePackage(package);
}
}
}
public AppInfo Create()
{
var assembly = Assembly.GetExecutingAssembly();
var semVer = new SemanticVersion(assembly.GetName().Version.ToStringInvariant());
return(new AppInfo(assembly.GetName().Name, semVer.ToNormalizedString()));
}
public virtual string GetPackageDirectory(string packageId, SemanticVersion version)
{
var directory = packageId;
directory += "." + version.ToNormalizedString();
return(directory);
}
public virtual string GetPackageFileName(string packageId, SemanticVersion version)
{
var fileNameBase = packageId;
fileNameBase += "." + version.ToNormalizedString();
return(fileNameBase + PackageConstants.PackageExtension);
}
public static NuGetVersion ToNuGetVersion([NotNull] this SemanticVersion version)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
return(NuGetVersion.Parse(version.ToNormalizedString()));
}
public void ToStringReturnsDropsMetadata(string version)
{
// Act
SemanticVersion semVer = new SemanticVersion(version);
// Assert
Assert.Equal(-1, semVer.ToString().IndexOf('+'));
Assert.Equal(-1, semVer.ToNormalizedString().IndexOf('+'));
}
public override string ToString()
{
if (SemanticVersion != null)
{
return(SemanticVersion.ToNormalizedString());
}
return($"[{Version}]");
}
public void NormalizeVersion_NormalizesVersionTo3Digits(string versionString, string expected)
{
// Arrange
var version = new SemanticVersion(versionString);
// Act
var result = version.ToNormalizedString();
// Assert
Assert.Equal(result, expected);
}
public string GetVersionString()
{
SemanticVersion version = GetVersion();
if (version != null)
{
return(version.ToNormalizedString());
}
return(null);
}
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 string GetNewVersion()
{
var existingVersion = SemanticVersion.Parse(_manifest.Metadata.Version);
var newVersion = new SemanticVersion(
existingVersion.Version.Major,
existingVersion.Version.Minor,
existingVersion.Version.Build + 1,
existingVersion.SpecialVersion);
return(newVersion.ToNormalizedString());
}
/// <summary>
/// Updates the global.json entries for tools.dotnet and sdk.version if they are older than an incoming version
/// </summary>
/// <param name="incomingDotnetVersion">version to compare against</param>
/// <param name="repoGlobalJson">Global.Json file to update</param>
/// <returns>Updated global.json file if was able to update, or the unchanged global.json if unable to</returns>
private GitFile UpdateDotnetVersionGlobalJson(SemanticVersion incomingDotnetVersion, GitFile repoGlobalJson)
{
string repoGlobalJsonContent = repoGlobalJson.ContentEncoding == ContentEncoding.Base64 ?
_gitClient.GetDecodedContent(repoGlobalJson.Content) :
repoGlobalJson.Content;
try
{
JObject parsedGlobalJson = JObject.Parse(repoGlobalJsonContent);
if (SemanticVersion.TryParse(parsedGlobalJson.SelectToken("tools.dotnet").ToString(), out SemanticVersion repoDotnetVersion))
{
if (repoDotnetVersion.CompareTo(incomingDotnetVersion) < 0)
{
parsedGlobalJson["tools"]["dotnet"] = incomingDotnetVersion.ToNormalizedString();
// Also update and keep sdk.version in sync.
JToken sdkVersion = parsedGlobalJson.SelectToken("sdk.version");
if (sdkVersion != null)
{
parsedGlobalJson["sdk"]["version"] = incomingDotnetVersion.ToNormalizedString();
}
return(new GitFile(VersionFiles.GlobalJson, parsedGlobalJson));
}
return(repoGlobalJson);
}
else
{
_logger.LogError("Could not parse the repo's dotnet version from the global.json. Skipping update to dotnet version sections");
return(repoGlobalJson);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to update Dotnet version for global.json. Skipping update to version sections.");
return(repoGlobalJson);
}
}
/// <summary>
/// Determines if a relative file path could have been generated by <see cref="ExpandedPackageRepository"/>.
/// The path is assumed to be relative to the base of the package directory.
/// </summary>
/// <param name="path">The file path to parse.</param>
/// <param name="id">The package ID found.</param>
/// <param name="version">The package version found.</param>
/// <returns>True if the file name is known.</returns>
public static bool TryParseFileName(string path, out string id, out SemanticVersion version)
{
id = null;
version = null;
if (path == null || Path.IsPathRooted(path))
{
return(false);
}
var pathPieces = path.Split(Path.DirectorySeparatorChar);
if (pathPieces.Length != 3) // {id}\{version}\{file name}
{
return(false);
}
id = pathPieces[pathPieces.Length - 3];
var unparsedVersion = pathPieces[pathPieces.Length - 2];
var fileName = pathPieces[pathPieces.Length - 1];
if (!SemanticVersion.TryParse(unparsedVersion, out version) ||
version.ToNormalizedString() != unparsedVersion)
{
return(false);
}
string expectedFileName;
if (fileName.EndsWith(NuGet.Constants.PackageExtension))
{
expectedFileName = $"{id}.{version}{NuGet.Constants.PackageExtension}";
}
else if (fileName.EndsWith(NuGet.Constants.HashFileExtension))
{
expectedFileName = $"{id}.{version}{NuGet.Constants.HashFileExtension}";
}
else if (fileName.EndsWith(NuGet.Constants.ManifestExtension))
{
expectedFileName = $"{id}{NuGet.Constants.ManifestExtension}";
}
else
{
return(false);
}
return(expectedFileName == fileName);
}
public Option <NugetPackage> Get(string id, SemanticVersion version)
{
try
{
const string sql = "SELECT * FROM dbo.NugetResultCache WHERE Id = @Id AND Version = @Version";
using (var con = new SqlConnection(_connectionString))
{
con.Open();
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("Id", id);
cmd.Parameters.AddWithValue("Version", version.ToNormalizedString());
var reader = cmd.ExecuteReader();
if (reader.Read())
{
var dependencies = ((string)reader["Dependencies"])
.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var frameworks = ((string)reader["Frameworks"])
.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
.Select(n => new FrameworkName(n)).ToArray();
var supportType = (SupportType)Enum.Parse(typeof(SupportType), (string)reader["SupportType"]);
return(new NugetPackage(
(string)reader["Id"],
dependencies,
supportType,
SemanticVersion.Parse((string)reader["Version"]),
frameworks
)
{
ProjectUrl = reader["ProjectUrl"] as string
});
}
else
{
return(Option <NugetPackage> .ToNone);
}
}
}
}
catch (Exception ex)
{
Log.Warning(ex, "Could not retrieve {id} {version} in Nuget Package Cache", id, version);
return(Option <NugetPackage> .ToNone);
}
}
public PackageVersion(string packageId, SemanticVersion version)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentException("Argument is null or whitespace", nameof(packageId));
}
PackageId = packageId;
Version = version;
Key = $"{PackageId}_{Version.ToNormalizedString()}";
}
public async Task <MayBe <InstalledPackage> > InstallPackageAsync(
DeploymentExecutionDefinition deploymentExecutionDefinition,
DirectoryInfo tempDirectory,
bool includeVersion = true,
SemanticVersion explicitVersion = null,
CancellationToken cancellationToken = default)
{
if (deploymentExecutionDefinition == null)
{
throw new ArgumentNullException(nameof(deploymentExecutionDefinition));
}
if (tempDirectory == null)
{
throw new ArgumentNullException(nameof(tempDirectory));
}
string executePath = deploymentExecutionDefinition.NuGetExePath.WithDefault(_deployerConfiguration.NuGetExePath);
if (string.IsNullOrWhiteSpace(executePath))
{
throw new InvalidOperationException("The NuGet executable file path is not defined");
}
if (!File.Exists(executePath))
{
throw new InvalidOperationException($"The NuGet executable file '{executePath}' does not exist");
}
var arguments = new List <string> {
"install", deploymentExecutionDefinition.PackageId
};
void AddVersion(string value)
{
arguments.Add("-Version");
arguments.Add(value);
}
if (explicitVersion != null)
{
AddVersion(explicitVersion.ToNormalizedString());
}
else if (deploymentExecutionDefinition.SemanticVersion is {})
private static string GetSimpleNuspecString(string packageId,
string packageVersion,
bool frameworkAssemblies,
SemanticVersion minClientVersion,
bool dependencies)
{
var frameworkAssemblyReferences = frameworkAssemblies ?
string.Format(FrameworkAssembliesStringFormat, "System.Xml", "net45") : string.Empty;
var minClientVersionString = minClientVersion == null ? string.Empty :
string.Format(MinClientVersionStringFormat, minClientVersion.ToNormalizedString());
var dependenciesString = dependencies ?
string.Format(DependenciesStringFormat, "Owin", "1.0") : string.Empty;
return(string.Format(NuspecStringFormat, packageId, packageVersion,
string.Join(Environment.NewLine, frameworkAssemblyReferences, dependenciesString),
minClientVersionString));
}
public void Constructor_DeserializesSemVer2Version()
{
// Arrange
var cacheFile = "{\"SchemaVersion\":\"3.0.0\",\"Packages\":[{\"Id\":\"" + PackageId + "\",\"Version\":\"" + SemVer2VersionString + "\"}]}";
var fileSystem = new Mock <IFileSystem>();
fileSystem
.Setup(x => x.FileExists(CacheFileName))
.Returns(true);
fileSystem
.Setup(x => x.OpenFile(CacheFileName))
.Returns(() => new MemoryStream(Encoding.UTF8.GetBytes(cacheFile)));
// Act
var actual = new ServerPackageCache(fileSystem.Object, CacheFileName);
// Assert
Assert.Equal(1, actual.GetAll().Count());
var package = actual.GetAll().First();
Assert.Equal(SemVer2Version.ToOriginalString(), package.Version.ToOriginalString());
Assert.Equal(SemVer2Version.ToFullString(), package.Version.ToFullString());
Assert.Equal(SemVer2Version.ToNormalizedString(), package.Version.ToNormalizedString());
}
private static void VerifyPreReleaseAllowed(
SemanticVersion version,
DeploymentTarget deploymentTarget,
string packageId,
ILogger logger)
{
if (version.IsPrerelease && !deploymentTarget.AllowPreRelease)
{
throw new DeployerAppException(
$"Could not deploy package with id '{packageId}' to target '{deploymentTarget}' because the package is a pre-release version and the target does not support it");
}
if (version.IsPrerelease)
{
if (logger.IsEnabled(LogEventLevel.Debug))
{
logger.Debug(
"The deployment target '{DeploymentTarget}' allows package id '{PackageId}' version {Version}, pre-release",
deploymentTarget,
packageId,
version.ToNormalizedString());
}
}
}
public void NormalizesStringOutputForDisplayAndUniqueness(SemanticVersion version, string expected)
{
Assert.Equal(expected, version.ToNormalizedString(), StringComparer.Ordinal);
}
async Task CheckForUpdates()
{
try
{
if (Config.Default.settings.update.isDisabled)
{
Trace.TraceInformation("The software update check is disabled by the user; skipping check");
return;
}
// Remove any old ClickOnce installs
try
{
var uninstallInfo = UninstallInfo.Find("IPFilter Updater");
if (uninstallInfo != null)
{
Trace.TraceWarning("Old ClickOnce app installed! Trying to remove...");
var uninstaller = new Uninstaller();
uninstaller.Uninstall(uninstallInfo);
Trace.TraceInformation("Successfully removed ClickOnce app");
}
}
catch (Exception ex)
{
Trace.TraceError("Failed to remove old ClickOnce app: " + ex);
}
var applicationDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "IPFilter");
var installerDir = new DirectoryInfo(Path.Combine(applicationDirectory, "installer"));
// Detect the current running version. The ProductVersion contains the informational, semantic version e.g. "3.0.0-beta"
var versionInfo = Process.GetCurrentProcess().MainModule.FileVersionInfo;
var currentVersion = new SemanticVersion(versionInfo.ProductVersion);
// Remove any old installers
try
{
if (!installerDir.Exists)
{
installerDir.Create();
}
else if (!Config.Default.settings.update.isCleanupDisabled)
{
// Don't delete the MSI for the current installed version
var currentMsiName = "IPFilter." + currentVersion.ToNormalizedString() + ".msi";
// Scan the directory for all installers
foreach (var fileInfo in installerDir.GetFiles("IPFilter.*.msi"))
{
// Don't remove the installer for the installed version
if (fileInfo.Name.Equals(currentMsiName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
Trace.TraceInformation("Removing cached installer: " + fileInfo.Name);
fileInfo.SafeDelete();
}
}
}
catch (Exception ex)
{
Trace.TraceError("Couldn't clean up old installers: " + ex);
}
Trace.TraceInformation("Checking for software updates...");
progress.Report(new ProgressModel(UpdateState.Downloading, "Checking for software updates...", -1));
var updater = new Updater();
var result = await updater.CheckForUpdateAsync(Config.Default.settings.update.isPreReleaseEnabled);
if (result == null)
{
return;
}
var latestVersion = new SemanticVersion(result.Version);
Update.IsUpdateAvailable = latestVersion > currentVersion;
if (Update.IsUpdateAvailable)
{
Update.AvailableVersion = latestVersion;
Update.IsUpdateRequired = true;
Update.MinimumRequiredVersion = latestVersion;
Update.UpdateSizeBytes = 2000000;
}
Trace.TraceInformation("Current version: {0}", Update.CurrentVersion);
Trace.TraceInformation("Available version: {0}", Update.AvailableVersion?.ToString() ?? "<no updates>");
if (!Update.IsUpdateAvailable)
{
return;
}
if (MessageBoxHelper.Show(dispatcher, "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.Yes,
"An update to version {0} is available. Would you like to update now?", Update.AvailableVersion) != MessageBoxResult.Yes)
{
return;
}
Trace.TraceInformation("Starting application update...");
// If we're not "installed", then don't check for updates. This is so the
// executable can be stand-alone. Stand-alone self-update to come later.
using (var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\IPFilter"))
{
var installPath = (string)key?.GetValue("InstallPath");
if (installPath == null)
{
using (var process = new Process())
{
process.StartInfo = new ProcessStartInfo("https://www.ipfilter.app/")
{
UseShellExecute = true
};
process.Start();
return;
}
}
}
// Download the MSI to the installer directory
var msiPath = Path.Combine(installerDir.FullName, "IPFilter." + Update.AvailableVersion + ".msi");
// Download the installer
using (var handler = new WebRequestHandler())
{
handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
var uri = new Uri($"{result.Uri}?{DateTime.Now.ToString("yyyyMMddHHmmss")}");
using (var httpClient = new HttpClient(handler))
using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken.Token))
{
if (cancellationToken.IsCancellationRequested)
{
progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
Update.IsUpdating = false;
return;
}
var length = response.Content.Headers.ContentLength;
double lengthInMb = !length.HasValue ? -1 : (double)length.Value / 1024 / 1024;
double bytesDownloaded = 0;
using (var stream = await response.Content.ReadAsStreamAsync())
using (var msi = File.Open(msiPath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
var buffer = new byte[65535 * 4];
int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
while (bytesRead != 0)
{
await msi.WriteAsync(buffer, 0, bytesRead, cancellationToken.Token);
bytesDownloaded += bytesRead;
if (length.HasValue)
{
double downloadedMegs = bytesDownloaded / 1024 / 1024;
var percent = (int)Math.Floor((bytesDownloaded / length.Value) * 100);
var status = string.Format(CultureInfo.CurrentUICulture, "Downloaded {0:F2} MB of {1:F2} MB", downloadedMegs, lengthInMb);
Update.IsUpdating = true;
Update.DownloadPercentage = percent;
progress.Report(new ProgressModel(UpdateState.Downloading, status, percent));
}
if (cancellationToken.IsCancellationRequested)
{
progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
Update.IsUpdating = false;
return;
}
bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
}
}
}
}
progress.Report(new ProgressModel(UpdateState.Ready, "Launching update...", 100));
Update.IsUpdating = false;
// Now run the installer
var sb = new StringBuilder("msiexec.exe ");
// Enable logging for the installer
var installLog = Path.Combine(applicationDirectory, "install.log");
sb.AppendFormat(" /l*v \"{0}\"", installLog);
sb.AppendFormat(" /i \"{0}\"", msiPath);
//sb.Append(" /passive");
ProcessInformation processInformation = new ProcessInformation();
StartupInfo startupInfo = new StartupInfo();
SecurityAttributes processSecurity = new SecurityAttributes();
SecurityAttributes threadSecurity = new SecurityAttributes();
processSecurity.nLength = Marshal.SizeOf(processSecurity);
threadSecurity.nLength = Marshal.SizeOf(threadSecurity);
const int NormalPriorityClass = 0x0020;
if (!ProcessManager.CreateProcess(null, sb, processSecurity,
threadSecurity, false, NormalPriorityClass,
IntPtr.Zero, null, startupInfo, processInformation))
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
try
{
//dispatcher.Invoke(DispatcherPriority.Normal, new Action(Application.Current.Shutdown));
Application.Current.Shutdown();
}
catch (Exception ex)
{
Trace.TraceError("Exception when shutting down app for update: " + ex);
Update.ErrorMessage = "Couldn't shutdown the app to apply update.";
}
}
catch (Exception ex)
{
Trace.TraceWarning("Application update check failed: " + ex);
}
finally
{
progress.Report(new ProgressModel(UpdateState.Ready, "Ready", 0));
}
}
private string GetHashFileName(string packageId, SemanticVersion version)
{
return(string.Format(TemplateHashFilename, packageId, version.ToNormalizedString(), NuGet.Constants.HashFileExtension));
}
private string GetPackageFileName(string packageId, SemanticVersion version)
{
return(string.Format(TemplateNupkgFilename, packageId, version.ToNormalizedString()));
}
public static string ToNormalizedStringSafe(this SemanticVersion self)
{
return(self != null?self.ToNormalizedString() : String.Empty);
}
private string GetHashFileName(string packageId, SemanticVersion version)
{
return string.Format(TemplateHashFilename, packageId, version.ToNormalizedString(), NuGet.Constants.HashFileExtension);
}
private static string GetPackagePath(string packageId, SemanticVersion version)
{
return(Path.Combine(
GetPackageRoot(packageId, version),
packageId + "." + version.ToNormalizedString() + Constants.PackageExtension));
}
public async Task Run()
{
// Gather download count data from statistics warehouse
IReadOnlyCollection <DownloadCountData> downloadData;
Trace.TraceInformation("Gathering Download Counts from {0}/{1}...", StatisticsDatabase.DataSource, StatisticsDatabase.InitialCatalog);
using (var connection = await StatisticsDatabase.ConnectTo())
using (var transaction = connection.BeginTransaction(IsolationLevel.Snapshot))
{
downloadData = (await connection.QueryWithRetryAsync <DownloadCountData>(
_storedProcedureName, commandType: CommandType.StoredProcedure, transaction: transaction, commandTimeout: _defaultCommandTimeout)).ToList();
}
Trace.TraceInformation("Gathered {0} rows of data.", downloadData.Count);
if (downloadData.Any())
{
SemanticVersion semanticVersion = null;
// Group based on Package Id
var grouped = downloadData.GroupBy(p => p.PackageId);
var registrations = new JArray();
foreach (var group in grouped)
{
var details = new JArray();
details.Add(group.Key);
foreach (var gv in group)
{
// downloads.v1.json should only contain normalized versions - ignore others
if (!string.IsNullOrEmpty(gv.PackageVersion) &&
SemanticVersion.TryParse(gv.PackageVersion, out semanticVersion) &&
gv.PackageVersion == semanticVersion.ToNormalizedString())
{
var version = new JArray(gv.PackageVersion, gv.TotalDownloadCount);
details.Add(version);
}
}
registrations.Add(details);
}
var reportText = registrations.ToString(Formatting.None);
foreach (var storageContainerTarget in Targets)
{
try
{
var targetBlobContainer = await GetBlobContainer(storageContainerTarget);
var blob = targetBlobContainer.GetBlockBlobReference(ReportName);
Trace.TraceInformation("Writing report to {0}", blob.Uri.AbsoluteUri);
blob.Properties.ContentType = "application/json";
await blob.UploadTextAsync(reportText);
Trace.TraceInformation("Wrote report to {0}", blob.Uri.AbsoluteUri);
}
catch (Exception ex)
{
Trace.TraceError("Error writing report to storage account {0}, container {1}. {2} {3}",
storageContainerTarget.StorageAccount.Credentials.AccountName,
storageContainerTarget.ContainerName, ex.Message, ex.StackTrace);
}
}
}
}
private static void LoadPackages(IEnumerable <string> packagePaths, Dictionary <string, PackageInfo> packages, string tempDirectoryOpt, bool release)
{
bool readOnly = tempDirectoryOpt == null;
foreach (var packagePath in packagePaths)
{
Package package;
string tempPathOpt;
if (readOnly)
{
tempPathOpt = null;
package = Package.Open(packagePath, FileMode.Open, FileAccess.Read);
}
else
{
tempPathOpt = Path.Combine(tempDirectoryOpt, Guid.NewGuid().ToString());
File.Copy(packagePath, tempPathOpt);
package = Package.Open(tempPathOpt, FileMode.Open, FileAccess.ReadWrite);
}
string packageId = null;
Stream nuspecStream = null;
XDocument nuspecXml = null;
PackageInfo packageInfo = null;
try
{
SemanticVersion packageVersion = null;
SemanticVersion newPackageVersion = null;
string nuspecXmlns = DefaultNuspecXmlns;
foreach (var part in package.GetParts())
{
string relativePath = part.Uri.OriginalString;
ParsePartName(relativePath, out var fileName, out var dirName);
if (dirName == "/" && fileName.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase))
{
nuspecStream = part.GetStream(FileMode.Open, readOnly ? FileAccess.Read : FileAccess.ReadWrite);
nuspecXml = XDocument.Load(nuspecStream);
if (nuspecXml.Root.HasAttributes)
{
var xmlNsAttribute = nuspecXml.Root.Attributes("xmlns").SingleOrDefault();
if (xmlNsAttribute != null)
{
nuspecXmlns = xmlNsAttribute.Value;
}
}
var metadata = nuspecXml.Element(XName.Get("package", nuspecXmlns))?.Element(XName.Get("metadata", nuspecXmlns));
if (metadata == null)
{
throw new InvalidDataException($"'{packagePath}' has invalid nuspec: missing 'metadata' element");
}
packageId = metadata.Element(XName.Get("id", nuspecXmlns))?.Value;
if (packageId == null)
{
throw new InvalidDataException($"'{packagePath}' has invalid nuspec: missing 'id' element");
}
var versionElement = metadata.Element(XName.Get("version", nuspecXmlns));
string packageVersionStr = versionElement?.Value;
if (packageVersionStr == null)
{
throw new InvalidDataException($"'{packagePath}' has invalid nuspec: missing 'version' element");
}
if (!SemanticVersion.TryParse(packageVersionStr, out packageVersion))
{
throw new InvalidDataException($"'{packagePath}' has invalid nuspec: invalid 'version' value '{packageVersionStr}'");
}
if (!packageVersion.IsPrerelease)
{
throw new InvalidOperationException($"Can only update pre-release packages: '{packagePath}' has release version");
}
// To strip build number take the first part of the pre-release label (e.g. "beta1-62030-10")
string releaseLabel = release ? null : packageVersion.Release.Split('-').First();
newPackageVersion = new SemanticVersion(packageVersion.Major, packageVersion.Minor, packageVersion.Patch, releaseLabel);
if (!readOnly)
{
versionElement.SetValue(newPackageVersion.ToNormalizedString());
}
break;
}
}
if (nuspecStream == null)
{
throw new InvalidDataException($"'{packagePath}' is missing .nuspec file");
}
if (packages.ContainsKey(packageId))
{
throw new InvalidDataException($"Multiple packages of name '{packageId}' specified");
}
if (!readOnly)
{
package.PackageProperties.Version = newPackageVersion.ToNormalizedString();
}
packageInfo = new PackageInfo(package, packageId, packageVersion, newPackageVersion, tempPathOpt, nuspecStream, nuspecXml, nuspecXmlns);
}
finally
{
if (packageInfo == null)
{
nuspecStream.Dispose();
package.Close();
if (tempPathOpt != null)
{
File.Delete(tempPathOpt);
}
}
}
packages.Add(packageId, packageInfo);
}
}
private AppInfoModel Create(Assembly assembly)
{
var semVer = new SemanticVersion(assembly.GetName().Version.ToStringInvariant());
return(new AppInfoModel(assembly.GetName().Name, semVer.ToNormalizedString()));
}
private string GetPackageFileName(string packageId, SemanticVersion version)
{
return string.Format(TemplateNupkgFilename, packageId, version.ToNormalizedString());
}
private async Task <bool?> CheckPackageExistsAsync(
FileInfo nugetPackage,
string nugetExePath,
ILogger logger,
string sourceName)
{
if (!File.Exists(nugetPackage.FullName))
{
logger.WriteError(
$"The NuGet package '{nugetPackage}' does not exist");
return(null);
}
logger.WriteDebug($"Searching for existing NuGet package '{nugetPackage}'");
string packageVersion;
string packageId;
using (var fs = new FileStream(nugetPackage.FullName, FileMode.Open, FileAccess.Read))
{
using (var archive = new ZipArchive(fs))
{
ZipArchiveEntry nuspecEntry =
archive.Entries.SingleOrDefault(
entry =>
Path.GetExtension(entry.Name)
.Equals(".nuspec", StringComparison.InvariantCultureIgnoreCase));
if (nuspecEntry == null)
{
throw new InvalidOperationException("The nuget package does not contain any nuspec");
}
var nuspecReader = new NuspecReader(nuspecEntry.Open());
NuGetVersion nuGetVersion = nuspecReader.GetVersion();
packageVersion = nuGetVersion.ToNormalizedString();
packageId = nuspecReader.GetIdentity().Id;
}
}
SemanticVersion expectedVersion = SemanticVersion.Parse(packageVersion);
var packageInfo = new { Id = packageId, Version = expectedVersion };
var args = new List <string>
{
"list",
packageId
};
if (!string.IsNullOrWhiteSpace(sourceName))
{
logger.WriteVerbose($"Using specific source name '{sourceName}'");
args.Add("-source");
args.Add(sourceName);
}
args.Add("-verbosity");
args.Add("normal");
if (packageInfo.Version.IsPrerelease)
{
logger.WriteVerbose($"Package '{nugetPackage.Name}' is pre-release");
args.Add("-prerelease");
}
var errorBuilder = new StringBuilder();
var standardBuilder = new List <string>();
string expectedNameAndVersion = $"{packageInfo.Id} {expectedVersion.ToNormalizedString()}";
logger.Write($"Looking for '{expectedNameAndVersion}' package");
ExitCode exitCode =
await
ProcessRunner.ExecuteAsync(
nugetExePath,
arguments : args,
standardOutLog :
(message, prefix) =>
{
standardBuilder.Add(message);
logger.Write(message, prefix);
},
standardErrorAction : (message, prefix) =>
{
errorBuilder.AppendLine(message);
logger.WriteError(message, prefix);
},
toolAction : logger.Write,
addProcessNameAsLogCategory : true,
addProcessRunnerCategory : true);
if (!exitCode.IsSuccess)
{
logger.WriteError($"Could not execute process to check if package '{expectedNameAndVersion}' exists");
return(null);
}
bool foundSpecificPackage = standardBuilder.Any(
line => line.Equals(expectedNameAndVersion, StringComparison.InvariantCultureIgnoreCase));
if (foundSpecificPackage)
{
logger.Write($"Found existing package id '{expectedNameAndVersion}'");
}
else
{
logger.Write($"Could not find existing package id '{expectedNameAndVersion}'");
}
return(foundSpecificPackage);
}
/// <inheritdoc/>
public AppInfoModel Create(Type type)
{
var semVer = new SemanticVersion(ReflectionHelper.GetAssemblyVersion(type));
return(new AppInfoModel(ReflectionHelper.GetAssemblyName(type), semVer.ToNormalizedString()));
}