|
static private GetPath ( |
||
| uri | ||
| return | string | |
internal static bool IsPackageFile(PackagePart part)
{
string path = UriUtility.GetPath(part.Uri);
string directory = Path.GetDirectoryName(path);
return(!Enumerable.Any <string>(ExcludePaths, p => directory.StartsWith(p, StringComparison.OrdinalIgnoreCase)) && !PackageHelper.IsManifest(path));
}
public override IEnumerable <FrameworkName> GetSupportedFrameworks()
{
IEnumerable <FrameworkName> enumerable;
IEnumerable <IPackageFile> enumerable2;
if (this._enableCaching && MemoryCache.Instance.TryGetValue <IEnumerable <IPackageFile> >(this.GetFilesCacheKey(), out enumerable2))
{
enumerable = from c in enumerable2 select c.TargetFramework;
}
else
{
using (Stream stream = this._streamFactory())
{
enumerable = Enumerable.Select <PackagePart, FrameworkName>(from part in Package.Open(stream).GetParts()
where IsPackageFile(part)
select part, delegate(PackagePart part) {
string effectivePath;
return(VersionUtility.ParseFrameworkNameFromFilePath(UriUtility.GetPath(part.Uri), out effectivePath));
});
}
}
return((from f in base.GetSupportedFrameworks().Concat <FrameworkName>(enumerable)
where f != null
select f).Distinct <FrameworkName>());
}
private static bool IsPackageFile(PackagePart part)
{
string path = UriUtility.GetPath(part.Uri);
// We exclude any opc files and the manifest file (.nuspec)
return(!ExcludePaths.Any(p => path.StartsWith(p, StringComparison.OrdinalIgnoreCase)) &&
!PackageUtility.IsManifest(path));
}
internal static bool IsPackageFile(PackagePart part, string packageId)
{
string path = UriUtility.GetPath(part.Uri);
string directory = Path.GetDirectoryName(path);
// We exclude any opc files and the auto-generated package manifest file ({packageId}.nuspec)
return(!ExcludePaths.Any(p => directory.StartsWith(p, StringComparison.OrdinalIgnoreCase)) &&
!PackageHelper.IsPackageManifest(path, packageId));
}
internal static bool IsPackageFile(Uri uri)
{
string path = UriUtility.GetPath(uri);
string directory = Path.GetDirectoryName(path);
// We exclude any opc files and the manifest file (.nuspec)
return(!ExcludePaths.Any(p => directory.StartsWith(p, StringComparison.OrdinalIgnoreCase)) &&
!PackageHelper.IsManifest(path));
}
private static bool IsAssemblyReference(PackagePart part)
{
// Assembly references are in lib/ and have a .dll/.exe extension
string path = UriUtility.GetPath(part.Uri);
return(path.StartsWith(AssemblyReferencesDir, StringComparison.OrdinalIgnoreCase) &&
// Exclude resource assemblies
!path.EndsWith(ResourceAssemblyExtension, StringComparison.OrdinalIgnoreCase) &&
AssemblyReferencesExtensions.Contains(Path.GetExtension(path), StringComparer.OrdinalIgnoreCase));
}
public ZipPackageFile(PackagePart part)
: base(UriUtility.GetPath(part.Uri))
{
Debug.Assert(part != null, "part should not be null");
byte[] buffer;
using (Stream partStream = part.GetStream())
{
buffer = partStream.ReadAllBytes();
}
_streamFactory = () => new MemoryStream(buffer);
}
public static string GetRelativePath(string path1, string path2)
{
if (path1 == null)
{
throw new ArgumentNullException("path1");
}
if (path2 == null)
{
throw new ArgumentNullException("path2");
}
return(UriUtility.GetPath(new Uri(path1).MakeRelativeUri(new Uri(path2))));
}
private void EnsurePackageFiles()
{
if (_files != null && _expandedFileSystem.DirectoryExists(_expandedFolderPath))
{
return;
}
_files = new Dictionary <string, PhysicalPackageFile>();
_supportedFrameworks = null;
using (Stream stream = GetStream())
{
Package package = Package.Open(stream);
_expandedFolderPath = GetExpandedFolderPath();
// 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)
{
Debug.Assert(part != null, "part should not be null");
byte[] buffer;
using (Stream partStream = part.GetStream()) {
using (var stream = new MemoryStream()) {
partStream.CopyTo(stream);
buffer = stream.ToArray();
}
}
_path = UriUtility.GetPath(part.Uri);
_streamFactory = () => new MemoryStream(buffer);
}
/// <summary>
/// Returns path2 relative to path1
/// </summary>
public static string GetRelativePath(string path1, string path2)
{
if (path1 == null)
{
throw new ArgumentNullException("path1");
}
if (path2 == null)
{
throw new ArgumentNullException("path2");
}
Uri source = new Uri(path1);
Uri target = new Uri(path2);
return(UriUtility.GetPath(source.MakeRelativeUri(target)));
}
public override void ExtractContents(IFileSystem fileSystem, string extractPath)
{
using (Stream stream = _streamFactory())
{
var package = Package.Open(stream);
foreach (var part in package.GetParts()
.Where(p => IsPackageFile(p, package.PackageProperties.Identifier)))
{
var relativePath = UriUtility.GetPath(part.Uri);
var targetPath = Path.Combine(extractPath, relativePath);
using (var partStream = part.GetStream())
{
fileSystem.AddFile(targetPath, partStream);
}
}
}
}
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(ZipEntry part)
: this(UriUtility.GetPath(new Uri(part.FileName, UriKind.Relative)), part)
{
}
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());
}
public ZipPackageFile(PackagePart part)
: base(UriUtility.GetPath(part.Uri))
{
Debug.Assert(part != null, "part should not be null");
_streamFactory = () => part.GetStream();
}
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;
}
}
}
}
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());
}
public ZipPackageFile(PackagePart part)
{
Path = UriUtility.GetPath(part.Uri);
_streamFactory = part.GetStream().ToStreamFactory();
}
/// <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));
}
