private void EnsurePackageFiles() { if (_files != null && _expandedFolderPath != null && _expandedFileSystem.DirectoryExists(_expandedFolderPath)) { return; } _files = new Dictionary <string, PhysicalPackageFile>(); _supportedFrameworks = null; var packageName = new PackageName(Id, Version); // Only use the cache for expanded folders under %temp%, or set from unit tests if (_expandedFileSystem == TempFileSystem || _forceUseCache) { Tuple <string, DateTimeOffset> cacheValue; DateTimeOffset lastModifiedTime = _fileSystem.GetLastModified(_packagePath); // if the cache doesn't exist, or it exists but points to a stale package, // then we invalidate the cache and store the new entry. if (!_cachedExpandedFolder.TryGetValue(packageName, out cacheValue) || cacheValue.Item2 < lastModifiedTime) { cacheValue = Tuple.Create(GetExpandedFolderPath(), lastModifiedTime); _cachedExpandedFolder[packageName] = cacheValue; } _expandedFolderPath = cacheValue.Item1; } else { _expandedFolderPath = GetExpandedFolderPath(); } using (Stream stream = GetStream()) { Package package = Package.Open(stream); // unzip files inside package var files = from part in package.GetParts() where ZipPackage.IsPackageFile(part, package.PackageProperties.Identifier) select part; // now copy all package's files to disk foreach (PackagePart file in files) { string path = UriUtility.GetPath(file.Uri); string filePath = Path.Combine(_expandedFolderPath, path); bool copyFile = true; if (_expandedFileSystem.FileExists(filePath)) { using (Stream partStream = file.GetStream(), targetStream = _expandedFileSystem.OpenFile(filePath)) { // if the target file already exists, // don't copy file if the lengths are equal. copyFile = partStream.Length != targetStream.Length; } } if (copyFile) { using (Stream partStream = file.GetStream()) { try { using (Stream targetStream = _expandedFileSystem.CreateFile(filePath)) { partStream.CopyTo(targetStream); } } catch (Exception) { // if the file is read-only or has an access denied issue, we just ignore it } } } var packageFile = new PhysicalPackageFile { SourcePath = _expandedFileSystem.GetFullPath(filePath), TargetPath = path }; _files[path] = packageFile; } } }
public ZipPackageFile(PackagePart part) : this(UriUtility.GetPath(part.Uri), part.GetStream().ToStreamFactory()) { }
public override IEnumerable <FrameworkName> GetSupportedFrameworks() { IEnumerable <FrameworkName> fileFrameworks; IEnumerable <IPackageFile> cachedFiles; if (_enableCaching && MemoryCache.Instance.TryGetValue(GetFilesCacheKey(), out cachedFiles)) { fileFrameworks = cachedFiles.Select(c => c.TargetFramework); } else { using (Stream stream = _streamFactory()) { var package = Package.Open(stream); string effectivePath; fileFrameworks = from part in package.GetParts() where IsPackageFile(part, Id) select VersionUtility.ParseFrameworkNameFromFilePath(UriUtility.GetPath(part.Uri), out effectivePath); } } return(base.GetSupportedFrameworks() .Concat(fileFrameworks) .Where(f => f != null) .Distinct()); }
/// <summary> /// Returns path2 relative to path1, with given path separator /// </summary> public static string GetRelativePath(string path1, string path2, char separator) { return(UriUtility.GetPath(GetRelativeUri(path1, path2), separator)); }
public ZipPackageFile(PackagePart part) { Path = UriUtility.GetPath(part.Uri); _streamFactory = part.GetStream().ToStreamFactory(); }
private void EnsurePackageFiles() { if ((this._files == null) || ((this._expandedFolderPath == null) || !this._expandedFileSystem.DirectoryExists(this._expandedFolderPath))) { this._files = new Dictionary <string, PhysicalPackageFile>(); this._supportedFrameworks = null; PackageName key = new PackageName(base.Id, base.Version); if (!ReferenceEquals(this._expandedFileSystem, _tempFileSystem) && !this._forceUseCache) { this._expandedFolderPath = this.GetExpandedFolderPath(); } else { Tuple <string, DateTimeOffset> tuple; DateTimeOffset lastModified = this._fileSystem.GetLastModified(this._packagePath); if (!_cachedExpandedFolder.TryGetValue(key, out tuple) || (tuple.Item2 < lastModified)) { tuple = Tuple.Create <string, DateTimeOffset>(this.GetExpandedFolderPath(), lastModified); _cachedExpandedFolder[key] = tuple; } this._expandedFolderPath = tuple.Item1; } using (Stream stream = this.GetStream()) { using (IEnumerator <PackagePart> enumerator = (from part in Package.Open(stream).GetParts() where ZipPackage.IsPackageFile(part) select part).GetEnumerator()) { string path; string str2; goto TR_0023; TR_000E: PhysicalPackageFile file1 = new PhysicalPackageFile(); file1.SourcePath = this._expandedFileSystem.GetFullPath(str2); file1.TargetPath = path; this._files[path] = file1; TR_0023: while (true) { if (enumerator.MoveNext()) { PackagePart current = enumerator.Current; path = UriUtility.GetPath(current.Uri); str2 = Path.Combine(this._expandedFolderPath, path); bool flag = true; if (this._expandedFileSystem.FileExists(str2)) { using (Stream stream2 = current.GetStream()) { using (Stream stream3 = this._expandedFileSystem.OpenFile(str2)) { flag = stream2.Length != stream3.Length; } } } if (flag) { Stream stream4 = current.GetStream(); try { using (Stream stream5 = this._expandedFileSystem.CreateFile(str2)) { stream4.CopyTo(stream5); } } catch (Exception) { } finally { if (stream4 != null) { stream4.Dispose(); } } } } else { return; } break; } goto TR_000E; } } } }
/// <summary> /// This routine was implemented to assist with finding credentials in the settings file using the uri /// It appears the package uri is used to find the credentials ex) https://hostname/api/nuget/Download/packagename/versionnumber /// but the settings file will more than likely only have the repository uri ex) https://hostname/api/nuget /// This routine will attempt to find the uri in settings as is /// If not found, see if source Uri is base of uri /// </summary> /// <param name="uri1">base or source URI</param> /// <param name="uri2">full URI</param> /// <returns></returns> public static bool UriStartsWith(Uri uri1, Uri uri2) { return(UriUtility.UriEquals(uri1, uri2) || uri1.IsBaseOf(uri2)); }
private void EnsurePackageFiles() { if (_files != null && _expandedFolderPath != null && _expandedFileSystem.DirectoryExists(_expandedFolderPath)) { return; } _files = new Dictionary <string, PhysicalPackageFile>(); _supportedFrameworks = null; var packageName = new PackageName(Id, Version); // Only use the cache for expanded folders under %temp%. if (_expandedFileSystem == _tempFileSystem) { _expandedFolderPath = _cachedExpandedFolder.GetOrAdd(packageName, _ => GetExpandedFolderPath()); } else { _expandedFolderPath = GetExpandedFolderPath(); } using (Stream stream = GetStream()) { Package package = Package.Open(stream); // unzip files inside package var files = from part in package.GetParts() where ZipPackage.IsPackageFile(part) select part; // now copy all package's files to disk foreach (PackagePart file in files) { string path = UriUtility.GetPath(file.Uri); string filePath = Path.Combine(_expandedFolderPath, path); using (Stream partStream = file.GetStream()) { // only copy the package part to disk if there doesn't exist // a file with the same name. if (!_expandedFileSystem.FileExists(filePath)) { using (Stream targetStream = _expandedFileSystem.CreateFile(filePath)) { partStream.CopyTo(targetStream); } } } var packageFile = new PhysicalPackageFile { SourcePath = _expandedFileSystem.GetFullPath(filePath), TargetPath = path }; _files[path] = packageFile; } } }
public ZipPackageFile(PackagePart part) : base(UriUtility.GetPath(part.Uri)) { Debug.Assert(part != null, "part should not be null"); _streamFactory = () => part.GetStream(); }
public ZipPackageFile(ZipEntry part) : this(UriUtility.GetPath(new Uri(part.FileName, UriKind.Relative)), part) { }
public override IEnumerable <FrameworkName> GetSupportedFrameworks() { IEnumerable <FrameworkName> fileFrameworks; IEnumerable <IPackageFile> cachedFiles; if (_enableCaching && MemoryCache.Instance.TryGetValue(GetFilesCacheKey(), out cachedFiles)) { fileFrameworks = cachedFiles.Select(c => c.TargetFramework); } else { using (Stream stream = _streamFactory()) { using (ZipFile zip = ZipFile.Read(stream)) { string effectivePath; fileFrameworks = from part in zip.Entries where IsPackageFile(new Uri(part.FileName, UriKind.Relative)) select VersionUtility.ParseFrameworkNameFromFilePath(UriUtility.GetPath(new Uri(part.FileName, UriKind.Relative)), out effectivePath); } } } return(base.GetSupportedFrameworks() .Concat(fileFrameworks) .Where(f => f != null) .Distinct()); }
private bool TryGetCredentials(Uri uri, out NetworkCredential configurationCredentials) { PackageSource source = Enumerable.FirstOrDefault <PackageSource>(this._packageSourceProvider.LoadPackageSources(), delegate(PackageSource p) { Uri uri; return(!string.IsNullOrEmpty(p.UserName) && (!string.IsNullOrEmpty(p.Password) && (Uri.TryCreate(p.Source, UriKind.Absolute, out uri) && UriUtility.UriStartsWith(uri, uri)))); }); if (source == null) { configurationCredentials = null; return(false); } configurationCredentials = new NetworkCredential(source.UserName, source.Password); return(true); }