/// <summary> /// Open a .dll file. /// </summary> /// <param name="filename"></param> /// <param name="packageInfo"></param> /// <returns>file provider</returns> public IFileProvider OpenFile(string filename, IPackageLoadInfo packageInfo) { try { return(DllFileProvider.OpenFile(filename, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(filename, e); } }
/// <summary> /// Use <paramref name="stream"/> to access contents of a .dll file. /// </summary> /// <param name="stream"></param> /// <param name="packageInfo"></param> /// <returns>file provider</returns> public IFileProvider UseStream(Stream stream, IPackageLoadInfo packageInfo) { try { return(DllFileProvider.UseStream(stream, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(stream is FileStream fs ? fs.Name : null, e); } }
/// <summary> /// Opens a .tar file with zero to multiple open file handles. /// Is thread-safe and thread-scalable (concurrent use is possible). /// </summary> /// <param name="filepath"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider to the contents of the package</returns> /// <exception cref="IOException">On I/O error</exception> /// <exception cref="PackageException.LoadError">on .tar error</exception> public IFileProvider OpenFile(string filepath, IPackageLoadInfo packageInfo) { try { return(new TarFileProvider(filepath, packageInfo?.Path, packageInfo?.LastModified, convertBackslashesToSlashes)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(filepath, e); } }
/// <summary> /// Reads .tar file from a stream. Takes ownership of the stream (closes it). /// Is thread-safe, but not thread-scalable (locks threads). /// </summary> /// <param name="stream"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider to the contents of the package</returns> /// <exception cref="IOException">On I/O error</exception> /// <exception cref="PackageException.LoadError">on .tar error</exception> public IFileProvider UseStream(Stream stream, IPackageLoadInfo packageInfo) { try { return(new TarFileProvider(stream, packageInfo?.Path, packageInfo?.LastModified, convertBackslashesToSlashes).AddDisposable(stream)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(null, e); } }
/// <summary> /// Read archive from a byte[]. The caller must close the returned file provider. /// </summary> /// <param name="data"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider to the contents of the package</returns> public IFileProvider UseBytes(byte[] data, IPackageLoadInfo packageInfo = null) { try { Func <TarArchive> opener = () => TarArchive.Open(new MemoryStream(data)); return(new TarFileProvider(opener, packageInfo?.Path, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(null, e); } }
/// <summary> /// Opens a .gz file with zero to multiple open file handles. /// Is thread-safe and thread-scalable (concurrent use is possible). /// </summary> /// <param name="filepath"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider to the contents of the package</returns> /// <exception cref="IOException">On I/O error</exception> /// <exception cref="PackageException.LoadError">on .gz error</exception> public IFileProvider OpenFile(string filepath, IPackageLoadInfo packageInfo) { string entryName = ExtractName(packageInfo?.Path) ?? fallbackEntryName; try { return(new GZipFileProvider(filepath, entryName, packageInfo?.Path, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(filepath, e); } }
/// <summary> /// Read archive from a byte[]. The caller must close the returned file provider. /// </summary> /// <param name="data"></param> /// <param name="packageInfo"></param> /// <returns></returns> public IFileProvider UseBytes(byte[] data, IPackageLoadInfo packageInfo = null) { string entryName = ExtractName(packageInfo?.Path) ?? fallbackEntryName; try { return(new BZip2FileProvider(data, entryName, packageInfo?.Path, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(null, e); } }
/// <summary> /// Reads .gz file from a stream. Takes ownership of the stream (closes it). /// Is thread-safe, but not thread-scalable (locks threads). /// </summary> /// <param name="stream"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider to the contents of the package</returns> /// <exception cref="IOException">On I/O error</exception> /// <exception cref="PackageException.LoadError">on .gz error</exception> public IFileProvider UseStream(Stream stream, IPackageLoadInfo packageInfo) { string entryName = ExtractName(packageInfo?.Path) ?? fallbackEntryName; try { return(new GZipFileProvider(stream, entryName, packageInfo?.Path, packageInfo?.LastModified).AddDisposable(stream)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { try { stream.Dispose(); } catch (Exception) { } throw new PackageException.LoadError(null, e); } }
/// <summary> /// Read archive from a byte[]. The caller must close the returned file provider. /// </summary> /// <param name="data"></param> /// <param name="packageInfo"></param> /// <returns></returns> public IFileProvider UseBytes(byte[] data, IPackageLoadInfo packageInfo = null) { string entryName = ExtractName(packageInfo?.Path) ?? fallbackEntryName; try { Func <GZipArchive> opener = () => GZipArchive.Open(new MemoryStream(data)); return(new GZipFileProvider(opener, entryName, packageInfo?.Path, packageInfo?.LastModified)); } catch (Exception e) when(e is InvalidDataException || e is FormatException || e is BadImageFormatException) { throw new PackageException.LoadError(null, e); } }
/// <summary> /// Load from byte[] /// </summary> /// <param name="data"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns></returns> public IFileProvider UseBytes(byte[] data, IPackageLoadInfo packageInfo) { AppDomain appDomain = AppDomain.CreateDomain(nameof(ManifestEmbeddedFileProvider) + "-" + Guid.NewGuid()); try { Assembly asm = appDomain.Load(data); Microsoft.Extensions.FileProviders.ManifestEmbeddedFileProvider embeddedFileProvider = new Microsoft.Extensions.FileProviders.ManifestEmbeddedFileProvider(asm); AppDomainUnloader disposable = new AppDomainUnloader(appDomain); IFileProvider fileProvider = new FileProviderHandle(o => (o as IDisposable).Dispose(), disposable, embeddedFileProvider); return(fileProvider); } catch (Exception e) { AppDomain.Unload(appDomain); throw new PackageException.LoadError(null, e); } }
/// <summary> /// Opens a .zip file with zero to multiple open file handles. /// Is thread-safe and thread-scalable (concurrent use is possible). /// </summary> /// <param name="filename"></param> /// <param name="packageInfo">(optional) clues about the file that is being opened</param> /// <returns>file provider that represents the package</returns> /// <exception cref="IOException">On I/O error</exception> /// <exception cref="PackageException.LoadError">on file format error</exception> public IFileProvider OpenFile(string filename, IPackageLoadInfo packageInfo) { try { return(new ZipFileProvider(filename, default, packageInfo?.Path, packageInfo?.LastModified));