public void CtorWithStream()
{
// Arrange
var builder = new PackageBuilder();
builder.Id = "Package";
builder.Version = new SemanticVersion("1.0");
builder.Authors.Add("David");
builder.Description = "This is a test package";
builder.ReleaseNotes = "This is a release note.";
builder.Copyright = "Copyright";
builder.Files.AddRange(PackageUtility.CreateFiles(new[] { @"lib\40\A.dll", @"content\foo" }));
var ms = new MemoryStream();
builder.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
// Act
var package = new ZipPackage(ms);
// Assert
Assert.Equal("Package", package.Id);
Assert.Equal(new SemanticVersion("1.0"), package.Version);
Assert.Equal("David", package.Authors.First());
Assert.Equal("Copyright", package.Copyright);
var files = package.GetFiles().ToList();
Assert.Equal(2, files.Count);
Assert.Equal(@"content\foo", files[0].Path);
Assert.Equal(@"lib\40\A.dll", files[1].Path);
var assemblyReferences = package.AssemblyReferences.ToList();
Assert.Equal(1, assemblyReferences.Count);
Assert.Equal("A.dll", assemblyReferences[0].Name);
Assert.Equal(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework);
Assert.Equal("This is a release note.", package.ReleaseNotes);
}
public void CreatePackage(HttpContextBase context)
{
var request = context.Request;
// Get the api key from the header
string apiKey = request.Headers[ApiKeyHeader];
// Get the package from the request body
Stream stream = request.Files.Count > 0 ? request.Files[0].InputStream : request.InputStream;
var package = new ZipPackage(stream);
// Make sure they can access this package
if (Authenticate(context, apiKey, package.Id))
{
try
{
_serverRepository.AddPackage(package);
WriteStatus(context, HttpStatusCode.Created, "");
}
catch (InvalidOperationException ex)
{
WriteStatus(context, HttpStatusCode.InternalServerError, ex.Message);
}
}
}
/// <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="package"></param>
/// <param name="exhaustive"></param>
/// <returns></returns>
public static bool IsPackageInstalled(this PackageManager packageManager, IPackage package, bool exhaustive = false)
{
var pathsDictionary = new Dictionary<string, bool>();
//Oh god oh god. The <center> cannot hold it is too late.
var useSideBySide = packageManager.PathResolver.GetPrivateField<bool>("_useSideBySidePaths");
pathsDictionary.Add(Path.Combine(packageManager.PathResolver.GetInstallPath(package),
packageManager.PathResolver.GetPackageFileName(package.Id, package.Version)), useSideBySide);
//We need to also check the inverse, to see if it was installed with the other setting....
if (exhaustive)
{
var inversePathResolver = new DefaultPackagePathResolver(packageManager.PathResolver.GetPrivateField<IFileSystem>("_fileSystem"), !useSideBySide);
pathsDictionary.Add(Path.Combine(inversePathResolver.GetInstallPath(package), inversePathResolver.GetPackageFileName(package.Id, package.Version)), !useSideBySide);
}
foreach (var path in pathsDictionary.Where(path => packageManager.FileSystem.FileExists(path.Key)))
{
if (path.Value)
{
return true;
}
//If not useSideBySide, we need to crack open the zip file.
//Need to crack the package open at this point and check the version, otherwise we just need to download it regardless
var zipPackage = new ZipPackage(packageManager.FileSystem.OpenFile(path.Key));
if (zipPackage.Version == package.Version)
{
return true;
}
}
//Its not here. Really. We tried.
return false;
}
/**
* Retrieve the zip entry of the core properties part.
*
* @throws OpenXml4NetException
* Throws if internal error occurs.
*/
public static ZipEntry GetCorePropertiesZipEntry(ZipPackage pkg)
{
PackageRelationship corePropsRel = pkg.GetRelationshipsByType(
PackageRelationshipTypes.CORE_PROPERTIES).GetRelationship(0);
if (corePropsRel == null)
return null;
ZipEntry ze = new ZipEntry(corePropsRel.TargetUri.OriginalString);
return ze;
}
public ActionResult AddLocalPackage(HttpPostedFileBase file)
{
if (file == null)
{
ModelState.AddModelError("PackageFileValidation", "No file selected. Please select a package file to upload.");
return(LocalRepository());
}
if (!Path.GetExtension(file.FileName).EndsWith("nupkg"))
{
ModelState.AddModelError("PackageFileValidation", "The file uploaded is not a valid package file, only Nuget packages are supported");
return(LocalRepository());
}
IPackage package;
try
{
package = new ZipPackage(file.InputStream);
}
catch (Exception ex)
{
LogHelper.Error <PackagingEditorController>("Package could not be unziped.", ex);
ModelState.AddModelError("PackageFileValidation", "The Nuget package file uploaded could not be read");
return(LocalRepository());
}
try
{
var fileName = Path.Combine(BackOfficeRequestContext.PackageContext.LocalPackageManager.SourceRepository.Source, file.FileName);
file.SaveAs(fileName);
}
catch (Exception ex)
{
ModelState.AddModelError("PackageFileValidation", "The package file could not be saved. " + ex.Message);
return(LocalRepository());
}
if (!string.IsNullOrWhiteSpace(Request.Form["autoinstall"]))
{
BackOfficeRequestContext.PackageContext.LocalPackageManager.InstallPackage(package, false);
Notifications.Add(new NotificationMessage(package.Title + " has been installed", "Package installed", NotificationType.Success));
SuccessfulOnRedirectAttribute.EnsureRouteData(this, "id", package.Id);
return(RedirectToAction("RecycleApplication", new { id = package.Id, state = PackageInstallationState.Installing }));
}
Notifications.Add(new NotificationMessage(package.Title + " added to local repository", "Package added", NotificationType.Success));
SuccessfulOnRedirectAttribute.EnsureRouteData(this, "id", package.Id);
return(RedirectToAction("LocalRepository"));
}
public Dictionary <ShortcutLocation, ShellLink> GetShortcutsForExecutable(string exeName, ShortcutLocation locations, string programArguments)
{
this.Log().Info("About to create shortcuts for {0}, rootAppDir {1}", exeName, rootAppDirectory);
var releases = Utility.LoadLocalReleases(Utility.LocalReleaseFileForAppDir(rootAppDirectory));
var thisRelease = Utility.FindCurrentVersion(releases);
var zf = new ZipPackage(Path.Combine(
Utility.PackageDirectoryForAppDir(rootAppDirectory),
thisRelease.Filename));
var exePath = Path.Combine(Utility.AppDirForRelease(rootAppDirectory, thisRelease), exeName);
var fileVerInfo = FileVersionInfo.GetVersionInfo(exePath);
var ret = new Dictionary <ShortcutLocation, ShellLink>();
foreach (var f in (ShortcutLocation[])Enum.GetValues(typeof(ShortcutLocation)))
{
if (!locations.HasFlag(f))
{
continue;
}
var file = linkTargetForVersionInfo(f, zf, fileVerInfo);
var appUserModelId = String.Format("com.squirrel.{0}.{1}", zf.Id.Replace(" ", ""), exeName.Replace(".exe", "").Replace(" ", ""));
var toastActivatorCLSDID = Utility.CreateGuidFromHash(appUserModelId).ToString();
this.Log().Info("Creating shortcut for {0} => {1}", exeName, file);
this.Log().Info("appUserModelId: {0} | toastActivatorCLSID: {1}", appUserModelId, toastActivatorCLSDID);
var target = Path.Combine(rootAppDirectory, exeName);
var sl = new ShellLink
{
Target = target,
IconPath = target,
IconIndex = 0,
WorkingDirectory = Path.GetDirectoryName(exePath),
Description = zf.Description,
};
if (!String.IsNullOrWhiteSpace(programArguments))
{
sl.Arguments += String.Format(" -a \"{0}\"", programArguments);
}
sl.SetAppUserModelId(appUserModelId);
sl.SetToastActivatorCLSID(toastActivatorCLSDID);
ret.Add(f, sl);
}
return(ret);
}
private bool OpenLocalPackageCore(string packagePath)
{
IPackage package = null;
string tempFile = null;
try
{
tempFile = Path.GetTempFileName();
File.Copy(packagePath, tempFile, overwrite: true);
var extension = Path.GetExtension(packagePath);
if (extension.Equals(Constants.PackageExtension, StringComparison.OrdinalIgnoreCase) ||
extension.Equals(Constants.SymbolPackageExtension, StringComparison.OrdinalIgnoreCase))
{
package = new ZipPackage(tempFile);
}
else if (extension.Equals(Constants.ManifestExtension, StringComparison.OrdinalIgnoreCase))
{
using (var str = ManifestUtility.ReadManifest(tempFile))
{
var builder = new PackageBuilder(str, Path.GetDirectoryName(packagePath));
package = builder.Build();
}
}
if (package != null)
{
LoadPackage(package, packagePath, PackageType.LocalPackage);
_tempFile = tempFile;
return(true);
}
}
catch (Exception ex)
{
package = null;
UIServices.Show(ex.Message, MessageLevel.Error);
return(false);
}
finally
{
if (package == null && tempFile != null && File.Exists(tempFile))
{
try
{
File.Delete(tempFile);
}
catch { /* ignore */ }
}
}
return(false);
}
private async void LoadSignatureData(ZipPackage package)
{
if (package.IsSigned)
{
PublisherSignature = package.PublisherSignature;
RepositorySignatures = package.RepositorySignatures;
await Task.Run(() => package.VerifySignatureAsync());
ValidationResult = new ValidationResultViewModel(package.VerificationResult);
}
}
public void ListCommand_VerboseOutput()
{
var nugetexe = Util.GetNuGetExePath();
using (var packageDirectory = TestDirectory.Create())
using (var randomTestFolder = TestDirectory.Create())
{
// Arrange
var packageFileName1 = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory);
var packageFileName2 = Util.CreateTestPackage("testPackage2", "2.1", packageDirectory);
var package1 = new ZipPackage(packageFileName1);
var package2 = new ZipPackage(packageFileName2);
using (var server = new MockServer())
{
string searchRequest = string.Empty;
server.Get.Add("/nuget/$metadata", r =>
Util.GetMockServerResource());
server.Get.Add("/nuget/Search()", r =>
new Action <HttpListenerResponse>(response =>
{
searchRequest = r.Url.ToString();
response.ContentType = "application/atom+xml;type=feed;charset=utf-8";
string feed = server.ToODataFeed(new[] { package1, package2 }, "Search");
MockServer.SetResponseContent(response, feed);
}));
server.Get.Add("/nuget", r => "OK");
server.Start();
// Act
var args = "list test -Verbosity detailed -Source " + server.Uri + "nuget";
var r1 = CommandRunner.Run(
nugetexe,
randomTestFolder,
args,
waitForExit: true);
server.Stop();
// Assert
Assert.Equal(0, r1.Item1);
// verify that the output is detailed
Assert.Contains(package1.Description, r1.Item2);
Assert.Contains(package2.Description, r1.Item2);
Assert.Contains("$filter=IsLatestVersion", searchRequest);
Assert.Contains("searchTerm='test", searchRequest);
Assert.Contains("includePrerelease=false", searchRequest);
}
}
}
public string GetReleaseNotes(string packageDirectory)
{
var zp = new ZipPackage(Path.Combine(packageDirectory, Filename));
var t = zp.Id;
if (String.IsNullOrWhiteSpace(zp.ReleaseNotes))
{
throw new Exception(String.Format("Invalid 'ReleaseNotes' value in nuspec file at '{0}'", Path.Combine(packageDirectory, Filename)));
}
return(zp.ReleaseNotes);
}
void AttemptToFindAndDownloadPackage(int attempt, string packageId, string packageVersion, string feed, string cacheDirectory, out IPackage downloadedPackage, out string path)
{
NuGet.PackageDownloader downloader;
var package = FindPackage(attempt, packageId, packageVersion, feed, out downloader);
var fullPathToDownloadTo = GetFilePathToDownloadPackageTo(cacheDirectory, package);
DownloadPackage(package, fullPathToDownloadTo, downloader);
path = fullPathToDownloadTo;
downloadedPackage = new ZipPackage(fullPathToDownloadTo);
}
public bool InstallPackage(string packageFullPath, out string installationMessage, bool updateAll = false)
{
this.PackageFullPath = packageFullPath;
ZipPackage zipPackage = new ZipPackage(PackageFullPath);
PackageId = zipPackage.Id;
PackageVersion = zipPackage.Version.ToString();
bool installed = vsProjectManager.InstallPackage(PackageId, PackageVersion, 10 * 60 * 1000, updateAll);
installationMessage = GetPackageInstallationOutput();
return(installed);
}
public void Initialize()
{
//extract package id and version.
packagePath = AppSettingsHelper.PackageFullPathKeyValue;
ZipPackage zipPackage = new ZipPackage(packagePath);
packageId = zipPackage.Id;
packageVersion = zipPackage.Version.ToString();
//set package sources.
string PackageSource = Path.GetDirectoryName(packagePath);
if (string.IsNullOrEmpty(PackageSource))
{
PackageSource = Environment.CurrentDirectory;
}
IList <KeyValuePair <string, string> > sources = new List <KeyValuePair <string, string> >();
sources.Add(new KeyValuePair <string, string>("TestSource", PackageSource));
//If additional sources are specified in the app.config file, add them too.
if (!string.IsNullOrEmpty(AppSettingsHelper.PackageSourceKeyValue))
{
string[] additionalPackageSources = AppSettingsHelper.PackageSourceKeyValue.Split(new char[] { ',', ';' });
int i = 1;
foreach (string additionalSource in additionalPackageSources)
{
sources.Add(new KeyValuePair <string, string>("AdditionalSources_" + i.ToString(), additionalSource));
i++;
}
}
NugetSettingsUtility.SetPackageSources(sources);
NugetSettingsUtility.SetActivePackageSource("TestSource", PackageSource);
//Set test run directory.
if (string.IsNullOrEmpty(AppSettingsHelper.TestResultsPathKeyValue))
{
TestRunPath = Path.Combine(Environment.CurrentDirectory, packageId);
}
else
{
TestRunPath = AppSettingsHelper.TestResultsPathKeyValue;
}
//Create root level test run Dir
if (!Directory.Exists(TestRunPath))
{
Directory.CreateDirectory(TestRunPath);
}
//initialize other values.
projName = DateTime.Now.Ticks.ToString();
vsVersion = (VSVersion)Enum.Parse(typeof(VSVersion), AppSettingsHelper.VSVersionKeyValue, true);
vsSKU = (VSSKU)Enum.Parse(typeof(VSSKU), AppSettingsHelper.VSSKUKeyValue, true);
}
private void PushPackageCore(string source, string apiKey, PackageServer packageServer, string packageToPush, TimeSpan timeout)
{
// Push the package to the server
var package = new ZipPackage(packageToPush);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), sourceName);
packageServer.PushPackage(apiKey, package.GetStream, Convert.ToInt32(timeout.TotalMilliseconds));
Console.WriteLine(NuGetResources.PushCommandPackagePushed);
}
// -------------------------- CreatePackage --------------------------
/// <summary>
/// Creates a package zip file containing specified
/// content and resource files.</summary>
private static void CreatePackage(string packagePath, bool withFiles, bool withDB, Player p)
{
// Create the Package
if (withDB)
{
Server.s.Log("Saving DB...");
SaveDatabase("SQL.sql");
Server.s.Log("Saved DB to SQL.sql");
}
Server.s.Log("Creating package...");
using (ZipPackage package = (ZipPackage)ZipPackage.Open(packagePath, FileMode.Create))
{
if (withFiles)
{
Server.s.Log("Collecting Directory structure...");
string currDir = Directory.GetCurrentDirectory() + "\\";
List <Uri> partURIs = GetAllFiles(new DirectoryInfo("./"), new Uri(currDir));
Server.s.Log("Structure complete");
Server.s.Log("Saving data...");
foreach (Uri loc in partURIs)
{
if (!Uri.UnescapeDataString(loc.ToString()).Contains(packagePath))
{
// Add the part to the Package
ZipPackagePart packagePart =
(ZipPackagePart)package.CreatePart(loc, "");
// Copy the data to the Document Part
using (FileStream fileStream = new FileStream(
"./" + Uri.UnescapeDataString(loc.ToString()), FileMode.Open, FileAccess.Read))
{
CopyStream(fileStream, packagePart.GetStream());
} // end:using(fileStream) - Close and dispose fileStream.
}
} // end:foreach(Uri loc)
}
if (withDB)
{ // If we don't want to back up database, we don't do this part.
Server.s.Log("Compressing Database...");
ZipPackagePart packagePart =
(ZipPackagePart)package.CreatePart(new Uri("/SQL.sql", UriKind.Relative), "", CompressionOption.Normal);
CopyStream(File.OpenRead("SQL.sql"), packagePart.GetStream());
Server.s.Log("Database compressed.");
} // end:if(withFiles)
Server.s.Log("Data saved!");
} // end:using (Package package) - Close and dispose package.
Player.SendMessage(p, "Server backup (" + (withFiles ? "Everything" + (withDB ? "" : " but Database") : "Database") + "): Complete!");
Server.s.Log("Server backed up!");
}// end:CreatePackage()
private async void SignAndSaveAs()
{
var signViewModel = new SignPackageViewModel(ViewModel, ViewModel.UIServices, ViewModel.SettingsManager);
if (ViewModel.UIServices.OpenSignPackageDialog(signViewModel, out var signedPackagePath))
{
var packageName = ViewModel.PackageMetadata + NuGetPe.Constants.PackageExtension;
var title = "Save " + packageName;
const string filter = "NuGet package file (*.nupkg)|*.nupkg|NuGet Symbols package file (*.snupkg)|*.snupkg|All files (*.*)|*.*";
var initialDirectory = Path.IsPathRooted(ViewModel.PackageSource) ? ViewModel.PackageSource : null;
if (ViewModel.UIServices.OpenSaveFileDialog(title, packageName, initialDirectory, filter, /* overwritePrompt */ false,
out var selectedPackagePath, out var filterIndex))
{
if (filterIndex == 1 &&
!selectedPackagePath.EndsWith(NuGetPe.Constants.PackageExtension, StringComparison.OrdinalIgnoreCase))
{
selectedPackagePath += NuGetPe.Constants.PackageExtension;
}
// prompt if the file already exists on disk
if (File.Exists(selectedPackagePath))
{
var confirmed = ViewModel.UIServices.Confirm(
Resources.ConfirmToReplaceFile_Title,
string.Format(CultureInfo.CurrentCulture, Resources.ConfirmToReplaceFile, selectedPackagePath));
if (!confirmed)
{
return;
}
}
try
{
File.Copy(signedPackagePath, selectedPackagePath, overwrite: true);
ViewModel.OnSaved(selectedPackagePath);
ViewModel.PackageSource = selectedPackagePath;
ViewModel.PackageMetadata.ClearSignatures();
using (var package = new ZipPackage(selectedPackagePath))
{
await package.LoadSignatureDataAsync();
ViewModel.PackageMetadata.LoadSignatureData(package);
}
ViewModel.IsSigned = true;
}
catch (Exception ex)
{
ViewModel.UIServices.Show(ex.Message, MessageLevel.Error);
}
}
}
}
public async Task <IPackage> DownloadAsync(Revision revision)
{
var request = new GetArchiveLinkRequest(
accountName: AccountName,
repositoryName: RepositoryName,
revision: revision,
format: GitArchiveFormat.Zipball
);
var link = await client.GetArchiveLinkAsync(request).ConfigureAwait(false);
return(await ZipPackage.DownloadAsync(link, stripFirstLevel : true).ConfigureAwait(false));
}
/// <summary>
/// Function to unzip and restore a set of singing keys
/// </summary>
/// <param name="fromZipFile"></param>
/// <param name="certPath"></param>
public void Restore(string fromZipFile)
{
Package zipFilePackage = ZipPackage.Open(fromZipFile, FileMode.Open, FileAccess.ReadWrite);
//Iterate through the all the files that
//is added within the collection and
foreach (ZipPackagePart contentFile in zipFilePackage.GetParts())
{
createFile(contentFile);
}
zipFilePackage.Close();
}
internal void Save()
{
_sectionProperties.WriteToBody(_currentPart.Writer.TextWriter, _currentHeaderFooterReferences);
_firstSection = true;
_sectionProperties.Continuous = false;
WriteCloseTag(CT_Document.BodyElementName);
WriteCloseTag(_currentPart.Part.Tag);
Stream stream = ZipPackage.GetPart(new Uri(PartManager.CleanName(_currentPart.PartName), UriKind.Relative)).GetStream();
_currentPart.Writer.Interleave(stream, WriteInterleaverToDocument);
WriteNumberingPart();
_manager.Write();
}
private void FinishHeaderOrFooter()
{
if (_currentPart.Writer.Location == _currentPart.StartingLocation)
{
OpenXmlParagraphModel.WriteInvisibleParagraph(_currentPart.Writer.TextWriter);
}
WriteCloseTag(_currentPart.Part.Tag);
Stream stream = ZipPackage.GetPart(new Uri(PartManager.CleanName(_currentPart.PartName), UriKind.Relative)).GetStream();
_currentPart.Writer.Interleave(stream, WriteInterleaverToHeaderOrFooter);
_currentPart.Stream.Dispose();
_currentPart = _documentPart;
}
/// <summary>
/// Given the path to the nupkg file, returns the corresponding package ID.
/// </summary>
public string GetPackageIdFromNupkgFile(string filePath)
{
try
{
ZipPackage pack = new ZipPackage(filePath);
return(pack.Id);
}
catch (Exception e)
{
WriteLine(" Exception thrown while trying to create zippackage for :{0}. Message {1}", filePath, e.Message);
return(null);
}
}
/// <summary>
/// Extract snapshot file
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
internal static LoadActionParts LoadSnapshotZip(string path)
{
using (FileStream str = File.Open(path, FileMode.Open, FileAccess.Read))
using (Package package = ZipPackage.Open(str, FileMode.Open, FileAccess.Read))
{
var parts = package.GetParts();
var elementPart = (from p in parts where p.Uri.OriginalString == "/" + SaveAction.elementFileName select p.GetStream()).First();
A11yElement element = A11yElement.FromStream(elementPart);
elementPart.Close();
Bitmap bmp;
try
{
var bmpPart = (from p in parts where p.Uri.OriginalString == "/" + SaveAction.screenshotFileName select p.GetStream()).First();
bmp = LoadBmp(bmpPart);
bmpPart.Close();
}
catch (InvalidOperationException e) // Gets thrown if screenshot doesn't exist in file
{
e.ReportException();
bmp = null;
}
var metadataPart = (from p in parts where p.Uri.OriginalString == "/" + SaveAction.metadataFileName select p.GetStream()).First();
SnapshotMetaInfo meta = SnapshotMetaInfo.DeserializeFromStream(metadataPart);
metadataPart.Close();
IReadOnlyDictionary <int, CustomProperty> CustomProperties;
try
{
var customPropertiesPart = (from p in parts where p.Uri.OriginalString == "/" + SaveAction.customPropsFileName select p.GetStream()).First();
CustomProperties = LoadCustomProperties(customPropertiesPart);
customPropertiesPart.Close();
}
#pragma warning disable CA1031 // Do not catch general exception types: specific handlers placed in conditional below
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types: specific handlers placed in conditional below
{
if (!(e is InvalidOperationException)) // An expected exception thrown when file does not exist, such as in old a11ytest files
{
e.ReportException();
}
CustomProperties = null;
}
var selectedElement = element.FindDescendant(k => k.UniqueId == meta.ScreenshotElementId);
return(new LoadActionParts(element, bmp, selectedElement.SynthesizeBitmapFromElements(), meta));
}
}
public void Build_And_Packaged_XCopy_Has_Correct_Metadata()
{
System.Environment.CurrentDirectory = "samples".MapVcsRoot();
MsBuild("PowerDeploy.Sample.XCopy\\PowerDeploy.Sample.XCopy.csproj /t:clean,build /p:RunOctoPack=true /p:OctoPackPackageVersion=1.3.3.7 /p:Configuration=Release /v:m");
Assert.IsTrue(File.Exists(@"PowerDeploy.Sample.XCopy\obj\octopacked\PowerDeploy.Sample.XCopy.1.3.3.7.nupkg"));
var nupkg = new ZipPackage(@"PowerDeploy.Sample.XCopy\obj\octopacked\PowerDeploy.Sample.XCopy.1.3.3.7.nupkg");
Assert.AreEqual("1.3.3.7", nupkg.Version.ToString());
Assert.AreEqual("PowerDeploy.Sample.XCopy", nupkg.Id);
Assert.IsTrue(nupkg.GetFiles().Any(f => f.Path.Contains("powerdeploy.template.xml")));
}
public static void Export(string savePath)
{
// save configuration, as we're going to change it
Configuration.Save();
// create zipfile
using (var zipFile = ZipPackage.Open(savePath, FileMode.Create))
{
// copy log files
DirectoryInfo logDir = new DirectoryInfo(Installation.GetLogDirectory());
foreach (FileInfo file in logDir.GetFiles("*.log").Concat(logDir.GetFiles("*.bak")))
{
var logPart = zipFile.CreatePart(new Uri("/" + file.Name, UriKind.Relative), "", CompressionOption.Maximum);
File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite).CopyTo(logPart.GetStream());
}
// copy WebMediaPortal configuration (these don't contain any passwords, so we can copy them literally if they exist)
CopyConfigurationFile(zipFile, "WebMediaPortal.xml");
CopyConfigurationFile(zipFile, "StreamingPlatforms.xml");
// copy literal config files
WriteConfigFile(zipFile, (IConfigurationSerializer <MediaAccess>)Configuration.GetSerializer(ConfigurationFile.MediaAccess));
WriteConfigFile(zipFile, (IConfigurationSerializer <StreamingProfiles>)Configuration.GetSerializer(ConfigurationFile.StreamingProfiles));
// copy Authentication.xml without the passwords
var authPart = zipFile.CreatePart(new Uri("/Authentication.xml", UriKind.Relative), "", CompressionOption.Maximum);
var authSerializer = (IConfigurationSerializer <Authentication>)Configuration.GetSerializer(ConfigurationFile.Authentication);
foreach (var user in authSerializer.Get().Users)
{
user.SetPasswordFromPlaintext(PASSWORD_SUBSTITUTE);
}
authSerializer.Save(authSerializer.Get(), authPart.GetStream());
// copy Services.xml without network password
var servicePart = zipFile.CreatePart(new Uri("/Services.xml", UriKind.Relative), "", CompressionOption.Maximum);
var serviceSerializer = (IConfigurationSerializer <ServicesConfig>)Configuration.GetSerializer(ConfigurationFile.Services);
serviceSerializer.Get().NetworkImpersonation.SetPasswordFromPlaintext(PASSWORD_SUBSTITUTE);
serviceSerializer.Save(serviceSerializer.Get(), servicePart.GetStream());
// copy Streaming.xml without watch sharing password
var streamingPart = zipFile.CreatePart(new Uri("/Streaming.xml", UriKind.Relative), "", CompressionOption.Maximum);
var streamingSerializer = (IConfigurationSerializer <Streaming>)Configuration.GetSerializer(ConfigurationFile.Streaming);
streamingSerializer.Get().WatchSharing.FollwitConfiguration["passwordHash"] = PASSWORD_SUBSTITUTE;
streamingSerializer.Get().WatchSharing.TraktConfiguration["passwordHash"] = PASSWORD_SUBSTITUTE;
streamingSerializer.Save(streamingSerializer.Get(), streamingPart.GetStream());
}
// reset the configuration after the changes we made to the passwords
Configuration.Reset();
}
public Dictionary <ShortcutLocation, ShellLink> GetShortcutsForExecutable(string exeName, ShortcutLocation locations, string programArguments)
{
this.Log().Info("About to create shortcuts for {0}, rootAppDir {1}", exeName, rootAppDirectory);
var releases = Utility.LoadLocalReleases(Utility.LocalReleaseFileForAppDir(rootAppDirectory));
var thisRelease = Utility.FindCurrentVersion(releases);
var updateExe = Path.Combine(rootAppDirectory, "update.exe");
var zf = new ZipPackage(Path.Combine(
Utility.PackageDirectoryForAppDir(rootAppDirectory),
thisRelease.Filename));
var exePath = Path.Combine(Utility.AppDirForRelease(rootAppDirectory, thisRelease), exeName);
var fileVerInfo = FileVersionInfo.GetVersionInfo(exePath);
var ret = new Dictionary <ShortcutLocation, ShellLink>();
foreach (var f in (ShortcutLocation[])Enum.GetValues(typeof(ShortcutLocation)))
{
if (!locations.HasFlag(f))
{
continue;
}
var file = linkTargetForVersionInfo(f, zf, fileVerInfo);
this.Log().Info("Creating shortcut for {0} => {1}", exeName, file);
ShellLink sl;
sl = new ShellLink {
Target = updateExe,
IconPath = exePath,
IconIndex = 0,
WorkingDirectory = Path.GetDirectoryName(exePath),
Description = zf.Description,
Arguments = "--processStart " + exeName,
};
if (!String.IsNullOrWhiteSpace(programArguments))
{
sl.Arguments += String.Format(" -a \"{0}\"", programArguments);
}
sl.SetAppUserModelId(String.Format("com.squirrel.{0}.{1}", zf.Id, exeName.Replace(".exe", "")));
sl.SetAppUserModelRelaunchCommand(String.Format("{0} {1}", sl.Target, sl.Arguments));
ret.Add(f, sl);
}
return(ret);
}
public static void ZipFiles(List <string> filesPath, string sZipPath, bool bOverwrite)
{
FileMode fileMode = bOverwrite ? FileMode.Create : FileMode.OpenOrCreate;
//Open the zip file if it exists, else create a new one
using (Package zip = ZipPackage.Open(sZipPath, fileMode, FileAccess.ReadWrite))
{
//Add as many files as you like:
foreach (var file in filesPath)
{
AddToArchive(zip, file);
}
}
} //End ZipFiles
private IEnumerable <NugetPackage> GetPackageDependencies(string name, string version, Project project)
{
const string keyDelimiter = "@@@";
var mapping = _packageList.ToDictionary(c => c.Name + keyDelimiter + c.Version, StringComparer.InvariantCultureIgnoreCase);
var dependencies = new List <NugetPackage>();
var nugetPackageFile = _solutionFolder + $@"\packages\{name}.{version}\{name}.{version}.nupkg";
if (File.Exists(nugetPackageFile))
{
var package = new ZipPackage(nugetPackageFile);
foreach (var dependency in package.GetCompatiblePackageDependencies(null))
{
var keys = mapping.Keys.Where(k => k.StartsWith(dependency.Id + keyDelimiter, StringComparison.InvariantCultureIgnoreCase));
string key = null;
if (keys.Count().Equals(1))
{
key = keys.First();
}
else if (keys.Count() > 1 && project != null) //if we have multiple packages with various versions, figure out which version is being used for this project
{
var projectPackage = project.Packages.FirstOrDefault(k => k.Name.StartsWith(dependency.Id, StringComparison.InvariantCultureIgnoreCase));
if (projectPackage != null)
{
key = keys.FirstOrDefault(k => k.Equals(dependency.Id + keyDelimiter + projectPackage.Version, StringComparison.InvariantCultureIgnoreCase));
}
}
if (key != null)
{
var dependentPackage = mapping[key];
if (
!dependencies.Any(
d => d.Name.Equals(dependentPackage.Name) && d.Version.Equals(dependentPackage.Version)))
{
dependencies.Add(new NugetPackage
{
Name = dependentPackage.Name,
Version = dependentPackage.Version
});
}
}
}
}
return(dependencies);
}
/**
* Retrieve the zip entry of the core properties part.
*
* @throws OpenXml4NetException
* Throws if internal error occurs.
*/
public static ZipEntry GetCorePropertiesZipEntry(ZipPackage pkg)
{
PackageRelationship corePropsRel = pkg.GetRelationshipsByType(
PackageRelationshipTypes.CORE_PROPERTIES).GetRelationship(0);
if (corePropsRel == null)
{
return(null);
}
ZipEntry ze = new ZipEntry(corePropsRel.TargetUri.OriginalString);
return(ze);
}
public static void UnzipFiles(string zipLocation, string directory)
{
ZipPackage zipFile = ZipPackage.Open(zipLocation, FileMode.Open) as ZipPackage;
foreach (ZipPackagePart part in zipFile.GetParts())
{
using (Stream source = part.GetStream(FileMode.Open, FileAccess.Read))
{
FileStream targetFile = File.OpenWrite(Path.Combine(directory, part.Uri.OriginalString.TrimStart('/')));
source.CopyTo(targetFile);
targetFile.Close();
}
}
}
/**
* Retrieve the Zip entry of the content types part.
*/
public static ZipEntry GetContentTypeZipEntry(ZipPackage pkg)
{
IEnumerator entries = pkg.ZipArchive.Entries;
// Enumerate through the Zip entries until we find the one named
// '[Content_Types].xml'.
while (entries.MoveNext())
{
ZipEntry entry = (ZipEntry)entries.Current;
if (entry.Name.Equals(
ContentTypeManager.CONTENT_TYPES_PART_NAME))
return entry;
}
return null;
}
/// <summary>
/// Decompress multiple files from a single zip file.
/// </summary>
/// <param name="bytBuffer">Byte array that contains the zip file.</param>
public void DecompressNPCs(byte[] bytBuffer)
{
string strFilePath = Path.Combine(GlobalOptions.ApplicationPath(), "saves");
// If the directory does not exist, create it.
if (!Directory.Exists(strFilePath))
{
Directory.CreateDirectory(strFilePath);
}
MemoryStream objStream = new MemoryStream();
objStream.Write(bytBuffer, 0, bytBuffer.Length);
Package objPackage = ZipPackage.Open(objStream, FileMode.Open, FileAccess.Read);
foreach (PackagePart objPart in objPackage.GetParts())
{
string strTarget = Path.Combine(strFilePath, objPart.Uri.ToString().Replace('_', ' '));
Stream objSource = objPart.GetStream(FileMode.Open, FileAccess.Read);
string[] strDirectory = strTarget.Split('/');
if (!strDirectory[1].EndsWith(".chum"))
{
if (!Directory.Exists(Path.Combine(strFilePath, strDirectory[1])))
{
Directory.CreateDirectory(Path.Combine(strFilePath, strDirectory[1]));
}
}
if (!strDirectory[2].EndsWith(".chum"))
{
if (!Directory.Exists(Path.Combine(strFilePath, strDirectory[1] + Path.DirectorySeparatorChar + strDirectory[2])))
{
Directory.CreateDirectory(Path.Combine(strFilePath, strDirectory[1] + Path.DirectorySeparatorChar + strDirectory[2]));
}
}
Stream objDestination = File.OpenWrite(strFilePath + strTarget.Replace('/', Path.DirectorySeparatorChar));
byte[] bytFileBuffer = new byte[100000];
int intRead;
intRead = objSource.Read(bytFileBuffer, 0, bytFileBuffer.Length);
while (intRead > 0)
{
objDestination.Write(bytFileBuffer, 0, intRead);
intRead = objSource.Read(bytFileBuffer, 0, bytFileBuffer.Length);
}
objDestination.Close();
objSource.Close();
}
}
/// <summary>
/// Adds a file to the zip file
/// </summary>
/// <param name="File">File to add</param>
public virtual void AddFile(string File)
{
File.ThrowIfNullOrEmpty("File");
FileInfo TempFileInfo = new FileInfo(File);
if (!TempFileInfo.Exists)
{
throw new ArgumentException("File");
}
using (Package Package = ZipPackage.Open(ZipFileStream, FileMode.OpenOrCreate))
{
AddFile(TempFileInfo.Name, TempFileInfo, Package);
}
}
public static byte[] ReplaceApplicationRibbonDiffXmlInSolutionBody(byte[] solutionBodyBinary, XElement newRibbonDiffXml)
{
using (var memStream = new MemoryStream())
{
memStream.Write(solutionBodyBinary, 0, solutionBodyBinary.Length);
using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open, FileAccess.ReadWrite))
{
ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/customizations.xml", UriKind.Relative));
if (part != null)
{
XDocument doc = null;
using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read))
{
doc = XDocument.Load(streamPart);
}
var ribbonDiffXml = doc.XPathSelectElement("ImportExportXml/RibbonDiffXml");
if (ribbonDiffXml != null)
{
ribbonDiffXml.ReplaceWith(newRibbonDiffXml);
}
using (Stream streamPart = part.GetStream(FileMode.Create, FileAccess.Write))
{
XmlWriterSettings settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = true,
Encoding = Encoding.UTF8
};
using (XmlWriter xmlWriter = XmlWriter.Create(streamPart, settings))
{
doc.Save(xmlWriter);
xmlWriter.Flush();
}
}
}
}
memStream.Position = 0;
byte[] result = memStream.ToArray();
return(result);
}
}
public PlatformExportManifest ReadPlatformExportManifest(Stream stream)
{
PlatformExportManifest retVal = null;
using (var package = ZipPackage.Open(stream, FileMode.Open))
{
var manifestPart = package.GetPart(_manifestPartUri);
using (var streamReader = new StreamReader(manifestPart.GetStream()))
{
retVal = streamReader.ReadToEnd().DeserializeXML <PlatformExportManifest>();
}
}
return(retVal);
}
/// <summary>
/// Adds a file to the zip file
/// </summary>
/// <param name="File">File to add</param>
public virtual void AddFile(string File)
{
Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(File), "File");
FileInfo TempFileInfo = new FileInfo(File);
if (!TempFileInfo.Exists)
{
throw new ArgumentException("File does not exist");
}
using (Package Package = ZipPackage.Open(ZipFileStream, FileMode.OpenOrCreate))
{
AddFile(TempFileInfo.Name, TempFileInfo, Package);
}
}
public void CreatePackage(HttpContextBase context)
{
RouteData routeData = GetRouteData(context);
var request = context.Request;
// Get the api key from the header
string apiKey = request.Headers[ApiKeyHeader];
// Get the package from the request body
Stream stream = request.Files.Count > 0 ? request.Files[0].InputStream : request.InputStream;
var package = new ZipPackage(stream);
// Make sure they can access this package
Authenticate(context, apiKey, package.Id,
() => _serverRepository.AddPackage(package));
}
public void CreatePackage(HttpContextBase context)
{
try {
_logger.Trace("Creating package...");
var request = context.Request;
_logger.Trace("Request context collected");
// Get the api key from the header
string apiKey = request.Headers[ApiKeyHeader];
if (!string.IsNullOrEmpty(apiKey))
_logger.Trace("apiKey collected (length={0})", apiKey.Length);
// Get the package from the request body
Stream stream = request.Files.Count > 0 ? request.Files[0].InputStream : request.InputStream;
var package = new ZipPackage(stream);
// Make sure they can access this package
_logger.Trace("Attempting to authenticate...");
if (Authenticate(context, apiKey, package.Id))
{
try
{
_logger.Trace("Adding package...");
_serverRepository.AddPackage(package);
WriteStatus(context, HttpStatusCode.Created, "");
}
catch (InvalidOperationException ex)
{
WriteStatus(context, HttpStatusCode.InternalServerError, ex.Message);
}
}
}
catch(Exception ex)
{
_logger.Error(ex, "CreatePackage(HttpContextBase)");
throw;
}
}
public void CtorWithStream()
{
// Arrange
var builder = new PackageBuilder();
builder.Id = "Package";
builder.Version = new SemanticVersion("1.0");
builder.Authors.Add("David");
builder.Description = "This is a test package";
builder.ReleaseNotes = "This is a release note.";
builder.Copyright = "Copyright";
builder.Files.AddRange(PackageUtility.CreateFiles(new[] { PathFixUtility.FixPath(@"lib\40\A.dll"), PathFixUtility.FixPath(@"content\foo") }));
var ms = new MemoryStream();
builder.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
// Act
var package = new ZipPackage(ms);
// Assert
Assert.Equal("Package", package.Id);
Assert.Equal(new SemanticVersion("1.0"), package.Version);
Assert.Equal("David", package.Authors.First());
Assert.Equal("Copyright", package.Copyright);
//Order is not gauranteed (or required) from GetFiles(),
//but we rely on the order for a few of the asserts,
//and it appears to not behave the same way on Mono,
//so we call "order by" here to force a specific order.
var files = package.GetFiles().OrderBy(k => k.Path).ToList();
Assert.Equal(2, files.Count);
Assert.Equal(PathFixUtility.FixPath(@"content\foo"), files[0].Path);
Assert.Equal(PathFixUtility.FixPath(@"lib\40\A.dll"), files[1].Path);
var assemblyReferences = package.AssemblyReferences.ToList();
Assert.Equal(1, assemblyReferences.Count);
Assert.Equal("A.dll", assemblyReferences[0].Name);
Assert.Equal(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework);
Assert.Equal("This is a release note.", package.ReleaseNotes);
}
public void Publish(string packagePath, string apiKey)
{
var logPath = _pathService.GetRelative(packagePath);
_context.WriteTrace(LogEntryType.Information,
$"Pushing \"{logPath}\" to NuGet repository");
var packageServer = new PackageServer(_sourceUrl, _userAgent);
try
{
var package = new ZipPackage(packagePath);
using (var stream = package.GetStream())
{
packageServer.PushPackage(apiKey, package, stream.Length, _publishTimeout, true);
_context.WriteTrace(LogEntryType.Information,
$"\"{logPath}\" was pushed successfully");
}
}
catch (Exception ex)
{
Trace.TraceError("*Exception: {0}, StackTrace", ex.Message, ex.StackTrace);
throw;
}
}
public bool Deploy(ZipPackage package, ILog logger)
{
var options = package.GetPackageOptions<WebOptions>();
logger.Info("Deploying iis package to {0}:{1} using {2}".Fmt(options.WebsiteName, options.WebsitePort, options.DeployService));
var client = new JsonServiceClient(options.DeployService); // todo
var request = new TriggerDeployment()
{
AppPoolName = "ZZZ_Integration_PoolName",
AppPoolUser = "******",
AppPoolPassword = "******",
WebsiteName = "ZZZ_Integration_Website_Simple",
AppRoot = "/",
PackageId = "IntegrationTest",
PackageVersion = "1.3.3.7",
WebsitePhysicalPath = @"C:\temp\integrationtests",
RuntimeVersion = RuntimeVersion.Version40,
};
var response = client.PostFileWithRequest<TriggerDeploymentResponse>("/deployments", new FileInfo("package.zip"), request);
return true;
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
// Try to return the source file from its uncompressed location
var parts = new[] {
package.Id,
package.Version.ToString(),
"src",
relativePath
};
var stream = OpenFile(Path.Combine(parts));
if (stream != null) return stream;
// If the file wasn't found uncompressed look for it in symbol package zip file
var packagePath = GetNupkgPath(package);
if (!File.Exists(packagePath)) return null;
var srcPath = Path.Combine("src", relativePath);
var packageFile = new ZipPackage(packagePath);
var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase));
return file != null ? file.GetStream() : null;
}
IEnumerable<ICommandOutput> ValidateInputs()
{
// TODO: HACK HACK HACK
var namedRepository = Remotes.PublishRepositories(Remote).SelectMany(_ => _).FirstOrDefault();
if (namedRepository == null)
{
yield return new UnknownRemoteName(Remote);
foreach (var _ in HintRemoteRepositories()) yield return _;
yield break;
}
if ((Username != null && Password == null) || (Username == null && Password != null))
{
yield return new IncompleteCredentials();
yield break;
}
bool hasAuth = Username != null && Password != null;
if (hasAuth) _credentials = new NetworkCredential(Username, Password);
_authenticationSupport = namedRepository.Feature<ISupportAuthentication>();
if (hasAuth && _authenticationSupport == null)
{
yield return new RemoteAuthenticatioNotSupported(namedRepository);
yield break;
}
_authenticationSupport = _authenticationSupport ?? new NullAuthentication();
//_repositories = namedRepository.
_remoteRepository = namedRepository;
var publishingRepo = _remoteRepository.Feature<ISupportPublishing>();
if (publishingRepo == null)
{
yield return new Error("Repository '{0}' doesn't support publishing.", namedRepository.Name);
yield break;
}
if (Path != null)
{
var packageFile = FileSystem.GetFile(Path);
if (!packageFile.Exists)
{
yield return new FileNotFound(Path);
yield break;
}
_packageStream = packageFile.OpenRead;
_packageFileName = packageFile.Name;
// TODO: This looks iffy at best
var package = new ZipPackage(packageFile);
_packageName = package.Name;
_packageVersion = package.Version;
}
else if (Name != null)
{
// get latest version of the Named package
if (!HostEnvironment.CurrentDirectoryRepository.PackagesByName.Contains(Name))
{
yield return new Error("No package named '{0}' was found.", Name);
yield break;
}
var packageToCopy = HostEnvironment.CurrentDirectoryRepository.PackagesByName[Name].OrderByDescending(x => x.Version).First();
_packageStream = () => packageToCopy.Load().OpenStream();
_packageFileName = packageToCopy.FullName + ".wrap";
_packageName = packageToCopy.Name;
_packageVersion = packageToCopy.Version;
}
else
{
yield return new Error("Please specify either a file path using the -Path input, or a name using -Name.");
}
}
public static ZipPackage GetZipPackage(string id, string version)
{
PackageBuilder builder = new PackageBuilder();
builder.Id = id;
builder.Version = SemanticVersion.Parse(version);
builder.Authors.Add("David");
builder.Description = "This is a test package";
builder.ReleaseNotes = "This is a release note.";
builder.Copyright = "Copyright";
builder.Files.AddRange(PackageUtility.CreateFiles(new[] { @"lib\foo" }));
var ms = new MemoryStream();
builder.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
var p = new ZipPackage(ms);
return p;
}
public void PackageBuilderWorksWithFileNamesContainingSpecialCharacters()
{
// Arrange
var fileNames = new[] {
@"lib\regular.file.dll",
@"lib\name with spaces.dll",
@"lib\C#\test.dll",
@"content\images\logo123?#78.png",
@"content\images\bread&butter.jpg",
};
// Act
var builder = new PackageBuilder { Id = "test", Version = new SemanticVersion("1.0"), Description = "test" };
builder.Authors.Add("test");
foreach (var name in fileNames)
{
builder.Files.Add(CreatePackageFile(name));
}
// Assert
using (MemoryStream stream = new MemoryStream())
{
builder.Save(stream);
var zipPackage = new ZipPackage(() => new MemoryStream(stream.ToArray()), enableCaching: false);
Assert.Equal(@"content\images\bread&butter.jpg", zipPackage.GetFiles().ElementAt(0).Path);
Assert.Equal(@"content\images\logo123?#78.png", zipPackage.GetFiles().ElementAt(1).Path);
Assert.Equal(@"lib\C#\test.dll", zipPackage.GetFiles().ElementAt(2).Path);
Assert.Equal(@"lib\name with spaces.dll", zipPackage.GetFiles().ElementAt(3).Path);
Assert.Equal(@"lib\regular.file.dll", zipPackage.GetFiles().ElementAt(4).Path);
}
}
private void PushPackage(string packagePath, string source, string apiKey = null)
{
var gallery = new GalleryServer(source);
// Use the specified api key or fall back to default behavior
apiKey = apiKey ?? GetApiKey(source);
// Push the package to the server
var package = new ZipPackage(packagePath);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), CommandLineUtility.GetSourceDisplayName(source));
using (Stream stream = package.GetStream()) {
gallery.CreatePackage(apiKey, stream);
}
// Publish the package on the server
if (!CreateOnly) {
var cmd = new PublishCommand();
cmd.Console = Console;
cmd.Source = source;
cmd.Arguments = new List<string> { package.Id, package.Version.ToString(), apiKey };
cmd.Execute();
}
else {
Console.WriteLine(NuGetResources.PushCommandPackageCreated, source);
}
}
private void PrintVerbose(string outputPath)
{
Console.WriteLine();
var package = new ZipPackage(outputPath);
Console.WriteLine("Id: {0}", package.Id);
Console.WriteLine("Version: {0}", package.Version);
Console.WriteLine("Authors: {0}", String.Join(", ", package.Authors));
Console.WriteLine("Description: {0}", package.Description);
if (package.LicenseUrl != null)
{
Console.WriteLine("License Url: {0}", package.LicenseUrl);
}
if (package.ProjectUrl != null)
{
Console.WriteLine("Project Url: {0}", package.ProjectUrl);
}
if (!String.IsNullOrEmpty(package.Tags))
{
Console.WriteLine("Tags: {0}", package.Tags.Trim());
}
if (package.DependencySets.Any())
{
Console.WriteLine("Dependencies: {0}", String.Join(", ", package.DependencySets.SelectMany(d => d.Dependencies).Select(d => d.ToString())));
}
else
{
Console.WriteLine("Dependencies: None");
}
Console.WriteLine();
foreach (var file in package.GetFiles().OrderBy(p => p.Path))
{
Console.WriteLine(NuGetResources.PackageCommandAddedFile, file.Path);
}
Console.WriteLine();
}
public void ListCommand_AllVersionsPrerelease()
{
var targetDir = ConfigurationManager.AppSettings["TargetDir"];
var nugetexe = Path.Combine(targetDir, "nuget.exe");
var tempPath = Path.GetTempPath();
var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
var mockServerEndPoint = "http://localhost:1234/";
try
{
// Arrange
Util.CreateDirectory(packageDirectory);
var packageFileName1 = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory);
var packageFileName2 = Util.CreateTestPackage("testPackage2", "2.1", packageDirectory);
var package1 = new ZipPackage(packageFileName1);
var package2 = new ZipPackage(packageFileName2);
var server = new MockServer(mockServerEndPoint);
string searchRequest = string.Empty;
server.Get.Add("/nuget/$metadata", r =>
MockServerResource.NuGetV2APIMetadata);
server.Get.Add("/nuget/Search()", r =>
new Action<HttpListenerResponse>(response =>
{
searchRequest = r.Url.ToString();
response.ContentType = "application/atom+xml;type=feed;charset=utf-8";
string feed = server.ToODataFeed(new[] { package1, package2 }, "Search");
MockServer.SetResponseContent(response, feed);
}));
server.Get.Add("/nuget", r => "OK");
server.Start();
// Act
var args = "list test -AllVersions -Prerelease -Source " + mockServerEndPoint + "nuget";
var r1 = CommandRunner.Run(
nugetexe,
tempPath,
args,
waitForExit: true);
server.Stop();
// Assert
Assert.Equal(0, r1.Item1);
// verify that the output is detailed
var expectedOutput = "testPackage1 1.1.0" + Environment.NewLine +
"testPackage2 2.1" + Environment.NewLine;
Assert.Equal(expectedOutput, r1.Item2);
Assert.DoesNotContain("$filter", searchRequest);
Assert.Contains("searchTerm='test", searchRequest);
Assert.Contains("includePrerelease=true", searchRequest);
}
finally
{
// Cleanup
Util.DeleteDirectory(packageDirectory);
}
}
private void PushPackage(string packagePath, string source, string apiKey) {
var packageServer = new PackageServer(source, "NuGet Command Line");
// Push the package to the server
var package = new ZipPackage(packagePath);
//HACK no pretty source name, as they have made the call to CommandLineUtility.GetSourceDisplayName(source) internal
Console.WriteLine("Pushing {0} to {1}", package.GetFullName(), source);
try
{
using (package.GetStream())
{
packageServer.PushPackage(apiKey, package, 60000);
}
}
catch
{
Console.WriteLine();
throw;
}
}
public void InstallCommand_DownloadPackageWhenHashChanges()
{
var targetDir = ConfigurationManager.AppSettings["TargetDir"];
var nugetexe = Path.Combine(targetDir, "nuget.exe");
var tempPath = Path.GetTempPath();
var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
var mockServerEndPoint = "http://localhost:1234/";
try
{
// Arrange
Util.CreateDirectory(packageDirectory);
Util.CreateDirectory(workingDirectory);
var packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory);
var package = new ZipPackage(packageFileName);
MachineCache.Default.RemovePackage(package);
// add the package to machine cache
MachineCache.Default.AddPackage(package);
// create a new package. Now this package has different hash value from the package in
// the machine cache.
packageFileName = Util.CreateTestPackage("testPackage1", "1.1.0", packageDirectory);
package = new ZipPackage(packageFileName);
var server = new MockServer(mockServerEndPoint);
string findPackagesByIdRequest = string.Empty;
bool packageDownloadIsCalled = false;
server.Get.Add("/nuget/FindPackagesById()", r =>
new Action<HttpListenerResponse>(response =>
{
findPackagesByIdRequest = r.Url.ToString();
response.ContentType = "application/atom+xml;type=feed;charset=utf-8";
string feed = server.ToODataFeed(new[] { package }, "FindPackagesById");
MockServer.SetResponseContent(response, feed);
}));
server.Get.Add("/nuget/Packages(Id='testPackage1',Version='1.1.0')", r =>
new Action<HttpListenerResponse>(response =>
{
response.ContentType = "application/atom+xml;type=entry;charset=utf-8";
var p1 = server.ToOData(package);
MockServer.SetResponseContent(response, p1);
}));
server.Get.Add("/package/testPackage1", r =>
new Action<HttpListenerResponse>(response =>
{
packageDownloadIsCalled = true;
response.ContentType = "application/zip";
using (var stream = package.GetStream())
{
var content = stream.ReadAllBytes();
MockServer.SetResponseContent(response, content);
}
}));
server.Get.Add("/nuget", r => "OK");
server.Start();
// Act
var args = "install testPackage1 -Source " + mockServerEndPoint + "nuget";
var r1 = CommandRunner.Run(
nugetexe,
workingDirectory,
args,
waitForExit: true);
server.Stop();
// Assert
Assert.Equal(0, r1.Item1);
Assert.Contains("$filter=IsLatestVersion", findPackagesByIdRequest);
// verifies that package is downloaded from server since the cached version has
// a different hash from the package on the server.
Assert.True(packageDownloadIsCalled);
}
finally
{
// Cleanup
Util.DeleteDirectory(packageDirectory);
Util.DeleteDirectory(workingDirectory);
}
}
private void PushPackage(string packagePath, string source, string apiKey)
{
var packageServer = new PackageServer(source, CommandLineConstants.UserAgent);
// Push the package to the server
var package = new ZipPackage(packagePath);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), sourceName);
using (Stream stream = package.GetStream())
{
packageServer.PushPackage(apiKey, stream);
}
if (CreateOnly)
{
Console.WriteWarning(NuGetResources.Warning_PublishPackageDeprecated);
}
Console.WriteLine(NuGetResources.PushCommandPackagePushed);
}
private void AddPackagesFromDropFolder()
{
_logger.Log(LogLevel.Info, "Start adding packages from drop folder.");
MonitorFileSystem(false);
try
{
var serverPackages = new HashSet<ServerPackage>(PackageEqualityComparer.IdAndVersion);
foreach (var packageFile in _fileSystem.GetFiles(_fileSystem.Root, "*.nupkg", false))
{
try
{
// Copy to correct filesystem location
var package = new ZipPackage(_fileSystem.OpenFile(packageFile));
_expandedPackageRepository.AddPackage(package);
_fileSystem.DeleteFile(packageFile);
// Mark for addition to metadata store
serverPackages.Add(CreateServerPackage(package, EnableDelisting));
}
catch (UnauthorizedAccessException ex)
{
// The file may be in use (still being copied) - ignore the error
_logger.Log(LogLevel.Error, "Error adding package file {0} from drop folder: {1}", packageFile, ex.Message);
}
catch (IOException ex)
{
// The file may be in use (still being copied) - ignore the error
_logger.Log(LogLevel.Error, "Error adding package file {0} from drop folder: {1}", packageFile, ex.Message);
}
}
// Add packages to metadata store in bulk
_serverPackageStore.StoreRange(serverPackages);
_serverPackageStore.PersistIfDirty();
_logger.Log(LogLevel.Info, "Finished adding packages from drop folder.");
}
finally
{
MonitorFileSystem(true);
}
}
internal static IPackage GetPackage(IPackageCacheRepository packageCache, PackageIdentity packageIdentity, Uri downloadUri)
{
var packageSemVer = CoreConverters.SafeToSemanticVersion(packageIdentity.Version);
var packageName = CoreConverters.SafeToPackageName(packageIdentity);
var downloader = new PackageDownloader();
IPackage package = null;
if (packageCache != null)
{
package = packageCache.FindPackage(packageName.Id, packageSemVer);
if (package != null)
{
NuGetTraceSources.ActionExecutor.Info(
"download/cachehit",
"[{0}] Download: Cache Hit!",
packageIdentity);
// Success!
return package;
}
if (downloadUri == null)
{
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture,
Strings.DownloadActionHandler_NoDownloadUrl,
packageIdentity));
}
// Try to download the package through the cache.
bool success = packageCache.InvokeOnPackage(
packageIdentity.Id,
packageSemVer,
(targetStream) =>
downloader.DownloadPackage(
new HttpClient(downloadUri),
packageName,
targetStream));
if (success)
{
NuGetTraceSources.ActionExecutor.Info(
"download/downloadedtocache",
"[{0}] Download: Downloaded to cache",
packageName);
// Try to get it from the cache again
package = packageCache.FindPackage(packageIdentity.Id, packageSemVer);
}
}
// Either:
// 1. We failed to load the package into the cache, which can happen when
// access to the %LocalAppData% directory is blocked,
// e.g. on Windows Azure Web Site build OR
// B. It was purged from the cache before it could be retrieved again.
// Regardless, the cache isn't working for us, so download it in to memory.
if (package == null)
{
NuGetTraceSources.ActionExecutor.Info(
"download/cachefailing",
"[{0}] Download: Cache isn't working. Downloading to RAM",
packageName);
using (var targetStream = new MemoryStream())
{
downloader.DownloadPackage(
new HttpClient(downloadUri),
packageName,
targetStream);
targetStream.Seek(0, SeekOrigin.Begin);
package = new ZipPackage(targetStream);
}
}
return package;
}
public void RestoreCommand_FromHttpSource()
{
var targetDir = ConfigurationManager.AppSettings["TargetDir"];
var nugetexe = Path.Combine(targetDir, "nuget.exe");
var tempPath = Path.GetTempPath();
var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
var packageDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
var mockServerEndPoint = "http://*****:*****@"
<packages>
<package id=""testPackage1"" version=""1.1.0"" />
</packages>");
var server = new MockServer(mockServerEndPoint);
bool getPackageByVersionIsCalled = false;
bool packageDownloadIsCalled = false;
server.Get.Add("/nuget/Packages(Id='testPackage1',Version='1.1.0')", r =>
new Action<HttpListenerResponse>(response =>
{
getPackageByVersionIsCalled = true;
response.ContentType = "application/atom+xml;type=entry;charset=utf-8";
var odata = server.ToOData(package);
MockServer.SetResponseContent(response, odata);
}));
server.Get.Add("/package/testPackage1", r =>
new Action<HttpListenerResponse>(response =>
{
packageDownloadIsCalled = true;
response.ContentType = "application/zip";
using (var stream = package.GetStream())
{
var content = stream.ReadAllBytes();
MockServer.SetResponseContent(response, content);
}
}));
server.Get.Add("/nuget", r => "OK");
server.Start();
// Act
var args = "restore packages.config -PackagesDirectory . -Source " + mockServerEndPoint + "nuget";
var r1 = CommandRunner.Run(
nugetexe,
workingDirectory,
args,
waitForExit: true);
server.Stop();
// Assert
Assert.Equal(0, r1.Item1);
Assert.True(getPackageByVersionIsCalled);
Assert.True(packageDownloadIsCalled);
}
finally
{
// Cleanup
Util.DeleteDirectory(packageDirectory);
Util.DeleteDirectory(workingDirectory);
}
}
void ImagesListView_ItemCommand(object sender, RadListViewCommandEventArgs e)
{
if (e.CommandName == "DownloadAllAsZip")
{
RadListViewDataItem item = ListViewAlbums.SelectedItems[0];
int parentID = Convert.ToInt32(item.GetDataKeyValue("ID").ToString());
string albumName = item.GetDataKeyValue("Name").ToString();
List<DataContext.Image> allImagesFromAlbum = (from a in context.Images
where a.AlbumID == parentID
select a).ToList();
MemoryStream memStream = new MemoryStream();
Package = ZipPackage.Create(memStream);
foreach (var image in allImagesFromAlbum)
{
Stream stream = new MemoryStream(image.Data);
Package.AddStream(stream, image.FileName);
}
Package.Close(false);
memStream.Position = 0;
if (memStream != null && memStream.Length > 0)
{
Response.Clear();
Response.AddHeader("content-disposition", "attachment; filename=" + albumName + ".zip");
Response.ContentType = "application/zip";
Response.BinaryWrite(memStream.ToArray());
Response.End();
}
}
if (e.CommandName == "DownloadImage")
{
RadListViewDataItem item = e.ListViewItem as RadListViewDataItem;
int imageID = Convert.ToInt32(item.GetDataKeyValue("ID").ToString());
DataContext.Image image = (from i in context.Images
where i.ID == imageID
select i).First();
byte[] data = image.Data;
string name = image.FileName;
if (data != null && data.Length > 0)
{
Response.Clear();
Response.ContentType = "application/octet-stream";
Response.AddHeader("content-disposition", "attachment; filename=" + name);
Response.BinaryWrite(data);
Response.End();
}
}
}
private void PushPackage(string packagePath, string source, string apiKey) {
var gallery = new GalleryServer(source);
// Push the package to the server
var package = new ZipPackage(packagePath);
bool complete = false;
gallery.ProgressAvailable += (sender, e) => {
Console.Write("\r" + "Pushing: {0}", e.PercentComplete);
if (e.PercentComplete == 100) {
Console.WriteLine();
complete = true;
}
};
Console.WriteLine("Pushing {0} to {1}", package.GetFullName(), SourceProvider.GetDisplayName(source));
try {
using (Stream stream = package.GetStream()) {
gallery.CreatePackage(apiKey, stream);
}
}
catch {
if (!complete) {
Console.WriteLine();
}
throw;
}
// Publish the package on the server
var cmd = new PublishCommand(SourceProvider);
cmd.Console = Console;
cmd.Source = source;
cmd.Arguments = new List<string> {
package.Id,
package.Version.ToString(),
apiKey
};
cmd.Execute();
}
private void PushPackageCore(string source, string apiKey, PackageServer packageServer, string packageToPush, TimeSpan timeout)
{
// Push the package to the server
var package = new ZipPackage(packageToPush);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), sourceName);
packageServer.PushPackage(apiKey, package, Convert.ToInt32(timeout.TotalMilliseconds));
Console.WriteLine(NuGetResources.PushCommandPackagePushed);
}
private void PushPackage(string packagePath, string source, string apiKey) {
var packageServer = new PackageServer(source, "NuGet Command Line");
// Push the package to the server
var package = new ZipPackage(packagePath);
bool complete = false;
//HACK no pretty source name, as they have made the call to CommandLineUtility.GetSourceDisplayName(source) internal
Console.WriteLine("Pushing {0} to {1}", package.GetFullName(), source);
try {
using (Stream stream = package.GetStream()) {
packageServer.PushPackage(apiKey, stream, 60000);
}
}
catch {
if (!complete) {
Console.WriteLine();
}
throw;
}
// Publish the package on the server
var cmd = new PublishCommand();
cmd.Console = Console;
cmd.Source = source;
cmd.Arguments.AddRange(new List<string> {
package.Id,
package.Version.ToString(),
apiKey
});
cmd.Execute();
}
private void PushPackageCore(string source, string apiKey, PackageServer packageServer, string packageToPush, TimeSpan timeout)
{
// Push the package to the server
var package = new ZipPackage(packageToPush);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
Console.WriteLine(NuGetResources.PushCommandPushingPackage, package.GetFullName(), sourceName);
using (Stream stream = package.GetStream())
{
packageServer.PushPackage(apiKey, stream, Convert.ToInt32(timeout.TotalMilliseconds));
}
if (CreateOnly)
{
Console.WriteWarning(NuGetResources.Warning_PublishPackageDeprecated);
}
Console.WriteLine(NuGetResources.PushCommandPackagePushed);
}
