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 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(); }
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 }
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 }