public string StoreData(byte[] data, string extension = null)
{
var hasher = new SHA256Managed();
hasher.Initialize();
string hash = null;
using (hasher)
{
hash = HexTools.ByteArrayToHexString(hasher.ComputeHash(data));
var targetPath = BuildPath(hash, extension);
if (_storage.Exists(targetPath))
{
return(null);
}
var directory = Path.GetDirectoryName(targetPath);
_storage.CreateFolder(directory);
var file = _storage.Open(targetPath);
using (file)
{
file.Write(data, 0, data.Length);
}
}
return(hash);
}
public OperationsWriter(IFileSystem fileSystem, FileHelper fileHelper)
{
_fileHelper = fileHelper;
_disposed = false;
_cleared = false;
_removed = false;
_fullWriter = new Lazy <XmlWriter>(
() => XmlWriter.Create(fileSystem.Open(fileHelper.ProductsFile, FileMode.CreateNew, FileAccess.Write),
new XmlWriterSettings
{
Indent = false,
OmitXmlDeclaration = false,
CloseOutput = true
}));
_addWriter = new Lazy <XmlWriter>(
() => XmlWriter.Create(fileSystem.Open(fileHelper.ProductsAddFile, FileMode.CreateNew, FileAccess.Write),
new XmlWriterSettings
{
CheckCharacters = true,
Indent = false,
OmitXmlDeclaration = true,
CloseOutput = true
}));
_delWriter = new Lazy <XmlWriter>(
() => XmlWriter.Create(fileSystem.Open(fileHelper.ProductsDelFile, FileMode.CreateNew, FileAccess.Write),
new XmlWriterSettings
{
Indent = false,
OmitXmlDeclaration = true,
CloseOutput = true
}));
}
public Stream OpenForRead()
{
return(_fileSystem.Open(
RelativePath,
FileMode.Open,
FileAccess.Read
));
}
public void TestOpenE2E()
{
string fileName = UploadFromString(ContentsText);
using (var reader = new StreamReader(_fileSystem.Open(PathToFile(fileName))))
{
string streamText = reader.ReadToEnd();
Assert.Equal(ContentsText, streamText);
}
}
public void Serialize(string rootPath, INode node, bool recursive = false)
{
string nodePath = Path.Combine(rootPath, node.Name.SanitizeUrl());
if (!_fileSystem.DirectoryExists(nodePath))
{
_fileSystem.CreateDirectory(nodePath);
}
var metaModel = new MetaModel(node, nodePath);
using (var fs = _fileSystem.Open(Path.Combine(nodePath, "Properties.txt"), FileMode.Create, FileAccess.Write, FileShare.None))
using (var writer = new StreamWriter(fs))
{
writer.WriteLine("Type: {0}", node.GetType().FullName);
writer.WriteLine("Urls: {0}", node.Uri);
writer.WriteLine("Template: {0}", node.Template);
writer.WriteLine("Publish: {0}", "Never");
writer.WriteLine("Unpublish: {0}", "Never");
}
foreach (var s in metaModel.Properties)
{
string path = Path.Combine(nodePath, s.Name.SanitizeUrl() + ".txt");
using (var fs = _fileSystem.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
using (var writer = new StreamWriter(fs))
{
writer.Write(s.Value.ToString());
}
}
foreach (var prop in metaModel.XmlProperties)
{
string path = Path.Combine(nodePath, prop.Name.SanitizeUrl() + ".xml");
using (var fs = _fileSystem.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
using (var writer = new StreamWriter(fs))
{
writer.Write(prop.Value.ToString());
}
}
// TODO
//foreach (var collection in collections.Where(c => !ExcludedProperties.Contains(c.Name)))
//{
//}
if (recursive)
{
foreach (var child in node.Children)
{
Serialize(rootPath: nodePath, node: child, recursive: true);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="fileIO"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static XProject Open(string path, IFileSystem fileIO, IJsonSerializer serializer)
{
using (var stream = fileIO.Open(path))
{
return Open(stream, fileIO, serializer);
}
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="fileIO"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static XProject Open(string path, IFileSystem fileIO, ITextSerializer serializer)
{
using (var stream = fileIO.Open(path))
{
return(Open(stream, fileIO, serializer));
}
}
public void Build(bool incremental)
{
if (_appConfig.EnableAds)
{
_indexSystem.Log("Extracting ads.");
var ads = Enumerable.Empty <IEntity>();
if (!incremental)
{
ads = new AdAttributeHelper().ConvertToAds(_dataTableMapper, _promotionEntryCodeProvider);
}
ads = UsePlugins(ads, incremental);
var allAds = ads.ToArray();
if (allAds.Any() || !incremental)
{
var adsXml = new XElement("operations",
new XElement("clear",
new XElement("ad")),
new XElement("add",
ConvertAdsToXml(allAds)));
using (var file = _fileSystem.Open(_fileHelper.AdsFile, FileMode.CreateNew, FileAccess.Write))
{
adsXml.Save(file);
}
}
_indexSystem.Log("Done extracting ads.");
}
}
public void WriteConfiguration()
{
//if we have custom configuration, write and exit
if (!string.IsNullOrWhiteSpace(_appConfig.ConfigurationXmlFile))
{
TransferPrepared();
return;
}
using (var outFile = _fileSystem.Open(_fileHelper.ConfigurationFile, FileMode.CreateNew, FileAccess.Write))
using (var eSalesConfigurationWriter = new StreamWriter(outFile, Encoding.UTF8))
{
var eSalesConfiguration = new configuration
{
search_refinements = Loader.Load <search_refinements>(),
formats = Loader.Load <formats>().format,
tokenizations = Loader.Load <tokenizations>().tokenization,
normalizations = Loader.Load <normalizations>().normalization
};
_facetDict = _configuration.FacetAttributes.ToDictionary(fa => fa.Name);
eSalesConfiguration.product_attributes = GetProductAttributes().ToArray();
eSalesConfiguration.ad_attributes = GetAdAttributes().ToArray();
new XmlSerializer(eSalesConfiguration.GetType()).Serialize(eSalesConfigurationWriter, eSalesConfiguration);
eSalesConfigurationWriter.Flush();
}
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="fileIO"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static ProjectContainer Open(string path, IFileSystem fileIO, IJsonSerializer serializer)
{
using (var stream = fileIO.Open(path))
{
return(Open(stream, fileIO, serializer));
}
}
private void TestRemoteFile(IFileSystem fs, Uri path)
{
using (var s = fs.Open(path))
{
Assert.Equal(TestByte, s.ReadByte());
}
}
/// <inheritdoc/>
async Task <string> IEditorApplication.OnGetImageKeyAsync()
{
try
{
var dlg = new OpenFileDialog();
dlg.Filters.Add(new FileDialogFilter()
{
Name = "All", Extensions = { "*" }
});
var result = await dlg.ShowAsync(_mainWindow);
if (result != null)
{
var path = result.FirstOrDefault();
using (var stream = _fileIO.Open(path))
{
var bytes = _fileIO.ReadBinary(stream);
var key = _editor?.Project?.AddImageFromFile(path, bytes);
return(key);
}
}
return(null);
}
catch (Exception ex)
{
_log?.LogError($"{ex.Message}{Environment.NewLine}{ex.StackTrace}");
return(null);
}
}
private StrongNameKeyPair ReadStrongNameKeyPair(string filePath)
{
using (FileStream keyFile = _fileSystem.Open(filePath, FileMode.Open))
{
return(new StrongNameKeyPair(keyFile));
}
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem ram = new MemoryFileSystem();
IFileSystem os = FileSystem.OS;
IFileSystem fp = new PhysicalFileProvider(AppDomain.CurrentDomain.BaseDirectory).ToFileSystem()
.AddDisposeAction(fs => fs.FileProviderDisposable?.Dispose());
IFileSystem embedded = new EmbeddedFileSystem(typeof(Composition_Examples).Assembly);
IFileSystem composition = FileSystemExtensions.Concat(ram, os, fp, embedded)
.AddDisposable(embedded)
.AddDisposable(fp)
.AddDisposable(os);
#endregion Snippet_1
#region Snippet_2
foreach (var entry in composition.VisitTree(depth: 1))
{
Console.WriteLine(entry);
}
#endregion Snippet_2
#region Snippet_3
using (Stream s = composition.Open("docs.example-file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
Console.WriteLine(s.Length);
}
#endregion Snippet_3
}
{
#region Snippet_4
IFileSystem ram1 = new MemoryFileSystem();
IFileSystem ram2 = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(ram1, ram2);
// Create file of 1024 bytes
ram1.CreateFile("file.txt", new byte[1024]);
// Create file of 10 bytes
ram2.CreateFile("file.txt", new byte[10]);
// Get only one entry size of 1024 bytes.
composition.PrintTo(Console.Out, format: PrintTree.Format.Default | PrintTree.Format.Length);
#endregion Snippet_4
}
{
#region Snippet_5
IFileSystem filesystem = FileSystem.Application;
IFileSystem overrides = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(
(filesystem, null),
(overrides, Option.ReadOnly)
);
#endregion Snippet_5
}
}
/// <summary>
/// Read fields from text database file format.
/// </summary>
/// <param name="path">The fields file path.</param>
/// <param name="fs">The file system.</param>
/// <returns>The new instance of the <see cref="IDatabase"/> class</returns>
IDatabase ITextFieldReader <IDatabase> .Read(string path, IFileSystem fs)
{
using var stream = fs.Open(path);
var fields = ReadInternal(stream).ToList();
var name = System.IO.Path.GetFileNameWithoutExtension(path);
return(_serviceProvider.GetService <IFactory>().FromFields(name, fields));
}
public Stream Open(
string path,
FileMode mode,
FileAccess access
)
{
return(_underlying.Open(path, mode, access));
}
/// <summary>
/// loads a quake3 level from a stream
/// </summary>
/// <param name="fileName">file to load</param>
/// <returns>level as a mesh</returns>
public Mesh Load(string fileName)
{
Stream stream = fs.Open(fileName);
Mesh ret = Load(stream);
stream.Close();
return(ret);
}
public LocalFileStream(IFileSystem fileSystem, string relativePath, string contentType)
: base(contentType)
{
Contract.Requires(fileSystem != null);
RelativePath = relativePath;
_fileInfo = fileSystem.GetFileInfo(relativePath);
_stream = new Lazy<Stream>(() => fileSystem.Open(relativePath, FileMode.Open));
}
public void Import(bool incremental)
{
_indexSystem.Log("Importing products.");
using (var stream = _fileSystem.Open(_fileHelper.ProductsFile, FileMode.Open, FileAccess.Read))
{
_connector.ImportProducts(stream);
}
_indexSystem.Log("Done importing products.");
}
private IResource loadFile(string path)
{
if (!_fileSystem.FileExists(path))
{
Debug.WriteLine($"File system resource pack- failed to find resource at path: {path}");
return(null);
}
return(new AGSResource(path, _fileSystem.Open(path)));
}
/// <summary>
/// Read fields from text database file format.
/// </summary>
/// <param name="path">The fields file path.</param>
/// <param name="fs">The file system.</param>
/// <returns>The new instance of the <see cref="Database"/> class</returns>
Database ITextFieldReader <Database> .Read(string path, IFileSystem fs)
{
using (System.IO.Stream stream = fs.Open(path))
{
var fields = ReadInternal(stream).ToList();
var name = System.IO.Path.GetFileNameWithoutExtension(path);
return(Database.FromFields(name, fields));
}
}
public static string ReadTestFile(this IFileSystem fs, string name)
{
using (Stream s = fs.Open(name, FileAccess.Read, create: false))
{
using (StreamReader sr = new StreamReader(s))
{
return(sr.ReadToEnd());
}
}
}
public static void WriteTestFile(this IFileSystem fs, string name, Action <BinaryWriter> writer)
{
using (Stream s = fs.Open(name, FileAccess.Write, create: true))
{
using (BinaryWriter bw = new BinaryWriter(s))
{
writer(bw);
}
}
}
public static void WriteTestFile(this IFileSystem fs, string name, string content)
{
using (Stream s = fs.Open(name, FileAccess.Write, create: true))
{
using (StreamWriter sw = new StreamWriter(s))
{
sw.Write(content);
}
}
}
public static byte[] ReadAllBytes(
this IFileSystem fileSystem,
string name)
{
using var stream = fileSystem.Open(
name,
FileMode.Open,
FileAccess.Read
);
return(stream.ReadAllBytes());
}
public Stream Get(string urlPath, SvgMagicOptions options)
{
var cachedFile = GetCacheFilePathAndName(urlPath, options);
if (_fileSystem.Exists(cachedFile))
{
return(_fileSystem.Open(cachedFile));
}
return(null);
}
public void Import(bool incremental)
{
if (!incremental)
{
_indexSystem.Log("Importing configuration.");
using (var stream = _fileSystem.Open(_fileHelper.ConfigurationFile, FileMode.Open, FileAccess.Read))
{
_connector.ImportConfiguration(stream);
}
_indexSystem.Log("Done importing configuration.");
}
}
public void Import(bool incremental)
{
if (!incremental && _appConfig.EnableAds)
{
_indexSystem.Log("Importing ads.");
using (var stream = _fileSystem.Open(_fileHelper.AdsFile, FileMode.Open, FileAccess.Read))
{
_connector.ImportAds(stream);
}
_indexSystem.Log("Done importing ads.");
}
}
public void TestOpenE2E()
{
const string Text = "hello";
var blob = _container.GetBlockBlobReference(HelloFile);
UploadFromString(blob, Text);
Assert.True(CheckBlobExists(blob));
using (var reader = new StreamReader(_fileSystem.Open(PathToFile(HelloFile))))
{
string streamText = reader.ReadToEnd();
Assert.Equal(Text, streamText);
}
}
private bool TrySynchroniseResource(
IReadWriteFileResource sourceResource,
IFileSystem target,
IReadWriteFileResource[] targetResources)
{
var targetResource = targetResources.FirstOrDefault(
r => r.RelativePath == sourceResource.RelativePath
);
if (!TryDo(sourceResource.OpenForRead, out var sourceStream))
{
return(false);
}
if (!TryDo(
() => target.Open(sourceResource.RelativePath,
FileMode.OpenOrCreate,
FileAccess.ReadWrite
),
out var targetStream)
)
{
return(false);
}
NotifySyncStart(sourceResource, targetResource, sourceStream, targetStream);
var composition = ComposePipeline(sourceStream, targetStream);
try
{
composition.Drain();
NotifySyncComplete(
sourceResource,
targetResource ??
CreateFileResourcePropertiesFor(
target,
sourceResource)
);
RecordHistory(sourceResource);
}
catch (Exception ex)
{
NotifyError(sourceResource, targetResource, ex);
composition.Dispose();
return(false);
}
return(true);
}
public async Task StoreAsync(LogContext logContext, CancellationToken cancellationToken = default)
{
if (!Directory.Exists(DirectoryPath))
{
Directory.CreateDirectory(DirectoryPath);
}
var filePath = Path.Combine(DirectoryPath, $"{_storeOptions.FileName}");
await SemaphoreSlim.WaitAsync();
try
{
await using var fileStream = _fileSystem.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
bool isBegin = false;
if (fileStream.Length == 0)
{
isBegin = true;
await fileStream.WriteAsync(Utf8StartBracket, cancellationToken);
}
fileStream.Seek(isBegin ? 0 : -1, SeekOrigin.End);
var lastCharacter = (char)fileStream.ReadByte();
if (lastCharacter == ']')
{
fileStream.Seek(-1, SeekOrigin.End);
await fileStream.WriteAsync(Utf8Comma);
}
var logAsBytes = JsonSerializer.SerializeToUtf8Bytes(logContext, _options.JsonSerializerOptions);
await fileStream.WriteAsync(logAsBytes, cancellationToken);
await fileStream.WriteAsync(Utf8EndBracket, cancellationToken);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
}
finally
{
SemaphoreSlim.Release();
}
}
public async Task Save(byte[] contents)
{
_lastKnownChanges.OnNext(contents);
try
{
using (var file = _fs.Open(_path, FileMode.Create, FileAccess.Write, FileShare.Read))
{
await file.WriteAllBytesAsync(contents);
}
_errorsDuringSaving.OnNext(Optional.None());
}
catch (Exception e)
{
_errorsDuringSaving.OnNext(e);
}
}
private void TestRemoteFile(IFileSystem fs, Uri path)
{
using (var s = fs.Open(path))
{
Assert.Equal(TestByte, s.ReadByte());
}
}
public static GitPackIndex Open(IFileSystem fs, string path)
{
return Open(access => fs.Open(path, access, create: false));
}
