public async Task Foo()
{
IFilesStore store = null;
#region clean_up_2
await store.AsyncFilesCommands.Storage
.CleanUpAsync();
#endregion
#region retry_renaming_2
await store.AsyncFilesCommands.Storage
.RetryRenamingAsync();
#endregion
#region retry_copying_2
await store.AsyncFilesCommands.Storage
.RetryCopyingAsync();
#endregion
}
private async Task CreateSampleData(IFilesStore filesStore, int startIndex = 1, int count = 2)
{
for (var i = startIndex; i < startIndex + count; i++)
{
await filesStore.AsyncFilesCommands.UploadAsync(string.Format("file{0}.bin", i), new RandomStream(10 * i));
}
}
public async Task Foo()
{
IFilesStore store = null;
#region get_metadata_2
var metadata = await store
.AsyncFilesCommands
.GetMetadataForAsync("/movies/intro.avi");
#endregion
#region update_metadata_2
await store
.AsyncFilesCommands
.UpdateMetadataAsync(
"/movies/intro.avi",
new RavenJObject()
{
{
"AllowRead", "None"
}
});
#endregion
}
public FilesManager(IProductStore ProductStore, ILogger <ProdoctManager> logger, IMapper mapper, IFilesStore photoStore, ITransaction <ShoppingDbContext> transaction)
{
_filesStore = photoStore;
_logger = logger;
_mapper = mapper;
_transaction = transaction;
}
public async Task Foo()
{
IFilesStore store = null;
#region versioning_1
await store
.AsyncFilesCommands
.Configuration
.SetKeyAsync(
"Raven/Versioning/DefaultConfiguration",
new FileVersioningConfiguration
{
Id = "Raven/Versioning/DefaultConfiguration",
MaxRevisions = 10
});
#endregion
#region versioning_2
await store
.AsyncFilesCommands
.Configuration
.SetKeyAsync(
"Raven/Versioning/documents/temp",
new FileVersioningConfiguration
{
Id = "Raven/Versioning/documents/temp",
Exclude = true
});
#endregion
#region versioning_3
await store
.AsyncFilesCommands
.Configuration
.SetKeyAsync(
"Raven/Versioning/documents/temp/drafts",
new FileVersioningConfiguration
{
Id = "Raven/Versioning/documents/temp/drafts",
Exclude = false,
MaxRevisions = 5
});
#endregion
#region versioning_4
using (var session = store.OpenAsyncSession())
{
FileHeader[] revisions = await session
.GetRevisionsForAsync(
"/documents/temp/drafts/1.txt",
start : 0,
pageSize : 5);
}
#endregion
}
public async Task Foo()
{
IFilesStore store = null;
{
#region search_2
SearchResults results = await store
.AsyncFilesCommands
.SearchAsync("AllowRead:Everyone", new [] { "__key" });
#endregion
}
{
#region search_3
SearchResults results = await store
.AsyncFilesCommands
.SearchAsync(
"AllowRead:Everyone",
new[] { "__key", "-__fileName" } // sort ascending by full path, then by file name in descending order
);
#endregion
}
MemoryStream stream = null;
{
#region search_on_directory_2
await store.AsyncFilesCommands.UploadAsync("1.doc", stream);
await store.AsyncFilesCommands.UploadAsync("2.txt", stream);
await store.AsyncFilesCommands.UploadAsync("3.toc", stream);
await store.AsyncFilesCommands.UploadAsync("/backups/1.doc", stream);
SearchResults result = await store
.AsyncFilesCommands
.SearchOnDirectoryAsync(
"/",
FilesSortOptions.Name | FilesSortOptions.Desc,
"*.?oc"
); // will return 3.toc and 1.doc
#endregion
}
#region get_search_fields_2
await store.AsyncFilesCommands.UploadAsync("intro.txt", stream, new RavenJObject()
{
{ "Owner", "James" }
});
var terms = await store.AsyncFilesCommands.GetSearchFieldsAsync();
#endregion
}
public SynchronizationNotificationTests()
{
sourceStore = NewStore(0);
sourceClient = sourceStore.AsyncFilesCommands;
destinationStore = NewStore(1);
destinationClient = destinationStore.AsyncFilesCommands;
}
private async Task InitializeRandomFile(IFilesStore store, string name, int size)
{
using (var session = store.OpenAsyncSession())
{
session.RegisterUpload(name, CreateRandomFileStream(size));
await session.SaveChangesAsync();
}
}
public SynchronizationNotificationTests()
{
sourceStore = NewStore(0);
sourceClient = sourceStore.AsyncFilesCommands;
destinationStore = NewStore(1);
destinationClient = destinationStore.AsyncFilesCommands;
}
public ActorsController(
ApplicationDbContext context,
IMapper mapper,
IFilesStore filesStore) : base(context, mapper, filesStore)
{
_context = context;
_mapper = mapper;
_filesStore = filesStore;
}
private Task <ConflictNotification> WaitForConflictDetected(IFilesStore store, int notificationsNumber, int time)
{
return(store.Changes()
.ForConflicts()
.OfType <ConflictNotification>()
.Where(x => x.Status == ConflictStatus.Detected)
.Timeout(TimeSpan.FromSeconds(time))
.Take(notificationsNumber)
.ToTask());
}
public MoviesController(
ApplicationDbContext context,
IMapper mapper,
IFilesStore filesStore,
ILogger <MoviesController> logger) : base(context, mapper, filesStore)
{
_context = context;
_mapper = mapper;
_filesStore = filesStore;
_logger = logger;
}
public async Task Foo()
{
IFilesStore store = null;
#region session_usage_1
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
using (Stream content = File.OpenRead(@"C:\intro.avi"))
{
session.RegisterUpload("/movies/intro.avi", content);
await session.SaveChangesAsync();
}
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
FileHeader file = await session.LoadFileAsync("/movies/intro.avi");
using (Stream content = await session.DownloadAsync(file.FullPath))
{
/* ... */
}
if (file.CreationDate < DateTime.Now.AddDays(-1))
{
session.RegisterFileDeletion(file);
}
await session.SaveChangesAsync();
}
#endregion
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region unit_of_work_1
Assert.Same(await session.LoadFileAsync("/movies/intro.avi"), await session.LoadFileAsync("/movies/intro.avi"));
#endregion
}
#region unit_of_work_2
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
FileHeader file = await session.LoadFileAsync("/movies/intro.avi");
file.Metadata.Add("Owner", "James");
await session.SaveChangesAsync(); // will sent the metadata update to the file system
}
#endregion
}
public IList <string> GetFilesList(IFilesStore filesStore)
{
var files = filesStore.AsyncFilesCommands.BrowseAsync(0, 100).Result;
List <string> filesList = new List <string>();
foreach (var file in files)
{
filesList.Add(file.FullPath);
}
return(filesList);
}
public IList<string> GetFilesList(IFilesStore filesStore)
{
var files = filesStore.AsyncFilesCommands.BrowseAsync(0, 100).Result;
List<string> filesList = new List<string>();
foreach (var file in files)
{
filesList.Add(file.FullPath);
}
return filesList;
}
public async Task Foo()
{
IFilesStore store = null;
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_3
using (Stream content = File.OpenRead(@"C:\intro.avi"))
{
session.RegisterUpload("/movies/intro.avi", content);
await session.SaveChangesAsync();
}
#endregion
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_4
session.RegisterUpload("random.bin", 128, stream =>
{
var bytes = new byte[128];
new Random().NextBytes(bytes);
stream.Write(bytes, 0, 128);
});
await session.SaveChangesAsync();
#endregion
}
using (IAsyncFilesSession session = store.OpenAsyncSession())
{
#region register_upload_5
FileHeader ravenFile = await session.LoadFileAsync("/movies/intro.avi");
string localFile = @"C:\intro.avi";
if (ravenFile == null || new FileInfo(localFile).LastWriteTime - ravenFile.LastModified > TimeSpan.FromHours(1))
{
using (Stream content = File.OpenRead(localFile))
{
session.RegisterUpload(ravenFile, content);
await session.SaveChangesAsync();
}
}
#endregion
}
}
private async Task <Task <ConflictNotification> > WaitForConflictResolved(IFilesStore store, int notificationsNumber, int time)
{
var changes = store.Changes();
await changes.Task;
var conflicts = changes.ForConflicts();
await conflicts.Task;
return(conflicts
.OfType <ConflictNotification>()
.Where(x => x.Status == ConflictStatus.Resolved)
.Timeout(TimeSpan.FromSeconds(time))
.Take(notificationsNumber)
.ToTask());
}
public void Dispose()
{
if (session != null)
{
session.Dispose();
session = null;
}
if (store != null)
{
store.Dispose();
store = null;
}
}
public WhatAreCommands()
{
IFilesStore store = null;
#region commands_access
IAsyncFilesCommands commands = store.AsyncFilesCommands;
#endregion
#region commands_different_fs
IAsyncFilesCommands southwindCommands = store
.AsyncFilesCommands
.ForFileSystem("SouthwindFS")
.With(new NetworkCredential("user", "pass"));
#endregion
}
public Fab2018(string ravenDbUrl, string fab2018Db, string fab2018Dfs)
{
_store = new DocumentStore
{
Url = ravenDbUrl,
DefaultDatabase = fab2018Db
}.Initialize();
if (!string.IsNullOrWhiteSpace(fab2018Dfs))
{
_fileStore = new FilesStore
{
Url = ravenDbUrl,
DefaultFileSystem = fab2018Dfs
}
}
public void Foo()
{
IFilesStore store = null;
#region set_listeners
store.SetListeners(new FilesSessionListeners
{
DeleteListeners = new IFilesDeleteListener[] { /* ... */ },
ConflictListeners = new IFilesConflictListener[] { /* ... */ },
MetadataChangeListeners = new IMetadataChangeListener[] { /* ... */ }
});
#endregion
#region register_listener
store.Listeners.RegisterListener(new SampleListener());
#endregion
}
private async Task InitializeWithRandomFiles(IFilesStore store, int count, int maxFileSizeInKb = 1024)
{
var rnd = new Random();
var creationTasks = new Task[count];
for (int i = 0; i < count; i++)
{
string name = "file-" + rnd.Next() + ".bin";
int size = rnd.Next(maxFileSizeInKb) * 1024;
var content = (char)rnd.Next(byte.MaxValue);
creationTasks[i] = InitializeRandomFile(store, name, size);
}
await Task.WhenAll(creationTasks);
}
/// <summary>
/// Set max number of requests
/// </summary>
/// <param name="documentStore"></param>
private static void ConfigureMaxRequest(IFilesStore filesStore)
{
filesStore.Conventions.MaxNumberOfRequestsPerSession = 500000;
}
public async Task Foo()
{
IFilesStore store = null;
int start;
int pageSize;
#region browse_2
start = 0;
pageSize = 10;
FileHeader[] fileHeaders;
do
{
fileHeaders = await store
.AsyncFilesCommands
.BrowseAsync(start, pageSize);
start += pageSize;
} while (fileHeaders.Length == pageSize);
#endregion
#region get_2
FileHeader[] icons = await store
.AsyncFilesCommands
.GetAsync(new[]
{
"/images/icons/small/1.png", "/images/icons/large/1.png"
});
#endregion
#region starts_with_2
FileHeader[] images = await store
.AsyncFilesCommands
.StartsWithAsync("/images", null, 0, 128);
#endregion
#region starts_with_3
FileHeader[] jpgs = await store
.AsyncFilesCommands
.StartsWithAsync("/images", "*.jpg", 0, 128);
#endregion
#region stream_file_headers_2
using (var reader = await store.AsyncFilesCommands.StreamFileHeadersAsync(Etag.Empty))
{
while (await reader.MoveNextAsync())
{
FileHeader header = reader.Current;
}
}
#endregion
Stream content = null;
#region stream_query_2
var allFilesMatchingCriteria = new List <FileHeader>();
using (var reader = await store.AsyncFilesCommands.StreamQueryAsync("", sortFields: new string[] { "-__key" }))
{
while (await reader.MoveNextAsync())
{
allFilesMatchingCriteria.Add(reader.Current);
}
}
#endregion
#region stream_query_3
using (var reader = await store.AsyncFilesCommands.StreamQueryAsync("Number:2", start: 10, pageSize: 20))
{
while (await reader.MoveNextAsync())
{
allFilesMatchingCriteria.Add(reader.Current);
}
}
#endregion
#region get_directories_2
await store.AsyncFilesCommands.UploadAsync("text-files/txt/a.txt", content);
await store.AsyncFilesCommands.UploadAsync("text-files/doc/a.doc", content);
await store.AsyncFilesCommands.UploadAsync("text-files/doc/drafts/a.doc", content);
await store.AsyncFilesCommands.UploadAsync("image-files/a.jpg", content);
string[] dirs;
dirs = await store.AsyncFilesCommands.GetDirectoriesAsync(); // will return "/image-files" and "/text-files"
dirs = await store.AsyncFilesCommands.GetDirectoriesAsync("/text-files"); // will return "/text-files/doc" and "/text-files/txt"
dirs = await store.AsyncFilesCommands.GetDirectoriesAsync("/image-files"); // will return empty array
#endregion
}
public FileSessionTests()
{
filesStore = this.NewStore();
}
public CustomBaseController(ApplicationDbContext context, IMapper mapper, IFilesStore filesStore)
{
_context = context;
_mapper = mapper;
_filesStore = filesStore;
}
private async Task CreateSampleData(IFilesStore filesStore, int startIndex = 1 , int count = 2)
{
for (var i = startIndex; i < startIndex + count; i++)
{
await filesStore.AsyncFilesCommands.UploadAsync(string.Format("file{0}.bin", i), new RandomStream(10 * i));
}
}
public HomeController(IFilesStore filesStore, IApplicationEnvironment appEnvironment)
{
_filesStore = filesStore;
_appEnvironment = appEnvironment;
}
public async Task Foo()
{
IFilesStore store = null;
#region get_destinations_2
SynchronizationDestination[] destinations = await store.AsyncFilesCommands.Synchronization
.GetDestinationsAsync();
#endregion
#region set_destinations_2
await store.AsyncFilesCommands.Synchronization.SetDestinationsAsync(new SynchronizationDestination
{
ServerUrl = "http://localhost:8080/",
FileSystem = "BackupFS"
});
#endregion
#region get_sync_status_2
SynchronizationReport report = await store.AsyncFilesCommands.Synchronization
.GetSynchronizationStatusForAsync("/documentation/readme.txt");
if (report.Exception == null)
{
Console.WriteLine("The file {0} has been synchronized successfully. The synchronization type: {1}",
report.FileName, report.Type);
}
else
{
Console.WriteLine("The synchronization of the file {0} failed. The exception message: {1}",
report.FileName, report.Exception.Message);
}
#endregion
{
#region get_finished_2
ItemsPage <SynchronizationReport> page;
IList <SynchronizationReport> reports = new List <SynchronizationReport>();
var start = 0;
const int pageSize = 10;
do
{
page = await store.AsyncFilesCommands.Synchronization.GetFinishedAsync(start, pageSize);
reports.AddRange(page.Items);
Console.WriteLine("Retrieved {0} of {1} reports", reports.Count, page.TotalCount);
} while (page.Items.Count == pageSize);
#endregion
}
{
#region get_active_2
ItemsPage <SynchronizationDetails> page = await store.AsyncFilesCommands.Synchronization
.GetActiveAsync(0, 128);
page.Items.ForEach(x =>
Console.WriteLine("Synchronization of {0} to {1} (type: {2}) is in progress",
x.FileName, x.DestinationUrl, x.Type));
#endregion
}
{
#region get_pending_2
ItemsPage <SynchronizationDetails> page = await store.AsyncFilesCommands.Synchronization
.GetPendingAsync(0, 128);
page.Items.ForEach(x =>
Console.WriteLine("File {0} waits to be synchronized to {1} (modification type: {2})",
x.FileName, x.DestinationUrl, x.Type));
#endregion
}
{
#region get_conflicts_2
ItemsPage <ConflictItem> page = await store.AsyncFilesCommands.Synchronization
.GetConflictsAsync(0, 128);
page.Items.ForEach(x =>
Console.WriteLine("Synchronization of file {0} from {1} file system resulted in conflict",
x.FileName, x.RemoteServerUrl));
#endregion
}
#region resolve_conflict_2
await store.AsyncFilesCommands.Synchronization
.ResolveConflictAsync("/documents/file.bin", ConflictResolutionStrategy.CurrentVersion);
#endregion
#region resolve_conflict_3
await store.AsyncFilesCommands.Synchronization
.ResolveConflictAsync("/documents/file.bin", ConflictResolutionStrategy.RemoteVersion);
#endregion
#region start_4
DestinationSyncResult[] results = await store.AsyncFilesCommands.Synchronization
.StartAsync();
foreach (var destinationSyncResult in results)
{
Console.WriteLine("Reports of synchronization to server {0}, fs {1}",
destinationSyncResult.DestinationServer, destinationSyncResult.DestinationFileSystem);
if (destinationSyncResult.Exception != null)
{
continue;
}
foreach (var fileReport in destinationSyncResult.Reports)
{
Console.WriteLine("\tFile {0} synchronization type: {1}", fileReport.FileName, fileReport.Type);
}
}
#endregion
{
#region start_5
SynchronizationReport syncReport = await store.AsyncFilesCommands.Synchronization
.StartAsync("/products/pictures/canon_1.jpg",
new SynchronizationDestination
{
FileSystem = "NorthwindFS",
ServerUrl = "http://localhost:8081/"
});
#endregion
}
}
public void DeleteFile(IDocumentSession document, IFilesStore fileStore, string file)
{
}
private Task<ConflictNotification> WaitForConflictDetected(IFilesStore store, int notificationsNumber, int time)
{
return store.Changes()
.ForConflicts()
.OfType<ConflictNotification>()
.Where(x => x.Status == ConflictStatus.Detected)
.Timeout(TimeSpan.FromSeconds(time))
.Take(notificationsNumber)
.ToTask();
}
private async Task<Task<ConflictNotification>> WaitForConflictResolved(IFilesStore store, int notificationsNumber, int time)
{
var changes = store.Changes();
await changes.Task;
var conflicts = changes.ForConflicts();
await conflicts.Task;
return conflicts
.OfType<ConflictNotification>()
.Where(x => x.Status == ConflictStatus.Resolved)
.Timeout(TimeSpan.FromSeconds(time))
.Take(notificationsNumber)
.ToTask();
}
public FileSessionTests()
{
filesStore = this.NewStore();
}
private async Task InitializeWithRandomFiles(IFilesStore store, int count, int maxFileSizeInKb = 1024)
{
var rnd = new Random();
var creationTasks = new Task[count];
for (int i = 0; i < count; i++)
{
string name = "file-" + rnd.Next() + ".bin";
int size = rnd.Next(maxFileSizeInKb / 2, maxFileSizeInKb) * 1024;
var content = (char)rnd.Next(byte.MaxValue);
creationTasks[i] = InitializeRandomFile(store, name, size);
}
await Task.WhenAll(creationTasks);
}
public async Task Foo()
{
IFilesStore store = null;
{
#region for_folder_2
IDisposable subscription = store
.Changes()
.ForFolder("/documents/books")
.Subscribe(change =>
{
switch (change.Action)
{
case FileChangeAction.Add:
// do something
break;
case FileChangeAction.Delete:
// do something
break;
}
});
#endregion
}
{
#region for_synchronization_2
IDisposable subscription = store
.Changes()
.ForSynchronization()
.Subscribe(notification =>
{
if (notification.Direction == SynchronizationDirection.Outgoing)
{
return;
}
switch (notification.Action)
{
case SynchronizationAction.Start:
// do something
break;
case SynchronizationAction.Finish:
// do something
break;
}
});
#endregion
}
{
#region for_conflicts_2
IDisposable subscription = store
.Changes()
.ForConflicts()
.Subscribe(conflict =>
{
switch (conflict.Status)
{
case ConflictStatus.Detected:
Console.WriteLine("New conflict! File name: {0}", conflict.FileName);
break;
case ConflictStatus.Resolved:
Console.WriteLine("Conflict resolved! File name: {0}", conflict.FileName);
break;
}
});
#endregion
}
{
#region for_configuration_2
IDisposable subscription = store
.Changes()
.ForConfiguration()
.Subscribe(change =>
{
switch (change.Action)
{
case ConfigurationChangeAction.Set:
// do something
break;
case ConfigurationChangeAction.Delete:
// do something
break;
}
});
#endregion
}
}
public async Task Foo()
{
IFilesStore store = null;
#region upload_2
using (var file = File.OpenRead(@"C:\intro.avi"))
{
await store
.AsyncFilesCommands
.UploadAsync(
"/movies/intro.avi",
file,
new RavenJObject
{
{
"AllowRead", "Everyone"
}
}
);
}
#endregion
#region upload_4
await store
.AsyncFilesCommands
.UploadAsync(
"two-bytes-file.bin",
s =>
{
s.WriteByte(1);
s.WriteByte(2);
},
null,
2,
new RavenJObject
{
{
"AllowRead", "Everyone"
}
}
);
#endregion
{
#region download_2
var metadata = new Reference <RavenJObject>();
var data = await store
.AsyncFilesCommands
.DownloadAsync(
"/movies/intro.avi",
metadata,
from : 0,
to : 200);
#endregion
}
#region rename_2
await store
.AsyncFilesCommands
.RenameAsync(
"/movies/intro.avi",
"/movies/introduction.avi"
);
#endregion
#region rename_3
await store
.AsyncFilesCommands
.RenameAsync(
"/movies/intro.avi",
"/movies/examples/intro.avi"
);
#endregion
#region delete_2
await store.AsyncFilesCommands.DeleteAsync("/movies/intro.avi");
#endregion
#region delete_by_query_2
await store.AsyncFilesCommands.DeleteByQueryAsync("__directoryName:/temp AND __level:2");
#endregion
}
private async Task InitializeRandomFile(IFilesStore store, string name, int size)
{
using (var session = store.OpenAsyncSession())
{
session.RegisterUpload(name, CreateRandomFileStream(size));
await session.SaveChangesAsync();
}
}
public RavenPreviewFileStorage(IFilesStore filesStore)
{
_filesStore = filesStore;
}
public async Task Foo()
{
IFilesStore store = null;
#region create_fs_2
await store.AsyncFilesCommands.Admin
.CreateFileSystemAsync(new FileSystemDocument
{
Id = "Raven/FileSystems/NorthwindFS",
Settings =
{
{ Constants.FileSystem.DataDirectory, "~/FileSystems/NorthwindFS" },
{ Constants.ActiveBundles, "Versioning" }
}
}, "NorthwindFS");
#endregion
#region ensure_fs_exists_2
await store.AsyncFilesCommands.Admin
.EnsureFileSystemExistsAsync("NorthwindFS");
#endregion
#region delete_fs_2
await store.AsyncFilesCommands.Admin
.DeleteFileSystemAsync(hardDelete : true);
#endregion
#region start_backup_2
await store.AsyncFilesCommands.Admin
.StartBackup(@"C:\backups\NorthwindFS", null, false, "NorthwindFS");
#endregion
#region start_backup_3
BackupStatus status = await store.AsyncFilesCommands.Configuration
.GetKeyAsync <BackupStatus>(BackupStatus.RavenBackupStatusDocumentKey);
if (status.IsRunning)
{
// ... //
}
#endregion
#region start_restore_2
long restoreOperationId = await store.AsyncFilesCommands.Admin
.StartRestore(new FilesystemRestoreRequest()
{
BackupLocation = @"C:\backups\NorthwindFS",
FilesystemLocation = @"~\FileSystems\NewNorthwindFS",
FilesystemName = "NewNorthwindFS"
});
#endregion
#region start_restore_3
using (var sysDbStore = new DocumentStore
{
Url = "http://localhost:8080/"
}.Initialize())
{
await new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, restoreOperationId)
.WaitForCompletionAsync();
}
#endregion
#region start_compact_2
long compactOperationId = await store.AsyncFilesCommands.Admin
.StartCompact("NorthwindFS");
#endregion
#region start_compact_3
using (var sysDbStore = new DocumentStore
{
Url = "http://localhost:8080/"
}.Initialize())
{
await new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, compactOperationId)
.WaitForCompletionAsync();
}
#endregion
#region reset_indexes_2
await store.AsyncFilesCommands.Admin
.ResetIndexes("NorthwindFS");
#endregion
#region get_names_2
string[] fsNames = await store.AsyncFilesCommands.Admin
.GetNamesAsync();
#endregion
#region get_stats_2
FileSystemStats[] fsStats = await store.AsyncFilesCommands.Admin
.GetStatisticsAsync();
#endregion
}
public void DeleteFile(IDocumentSession document, IFilesStore fileStore, string file)
{
}
