protected override void ModifyStore(FilesStore store) { FactIfWindowsAuthenticationIsAvailable.LoadCredentials(); ConfigurationHelper.ApplySettingsToConventions(store.Conventions); base.ModifyStore(store); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add MVC services to the services container. services.AddMvc(); services.AddSingleton(p => { var documentStore = new DocumentStore() { Url = Configuration["RavenDb:Url"], DefaultDatabase = Configuration["RavenDb:DefaultDatabase"] }.Initialize(); IndexCreation.CreateIndexes(this.GetType().Assembly, documentStore); return documentStore; }); services.AddSingleton(p => { var fsStore = new FilesStore() { Url = Configuration["RavenDb:Url"], DefaultFileSystem = Configuration["RavenDb:DefaultFilesStore"] }.Initialize(); return fsStore; }); }
/// <summary> /// Initializes a new instance of the <see cref="InMemoryFilesSessionOperations"/> class. /// </summary> protected InMemoryFilesSessionOperations(FilesStore filesStore, FilesSessionListeners listeners, Guid id) { this.Id = id; this.filesStore = filesStore; this.theListeners = listeners; this.MaxNumberOfRequestsPerSession = filesStore.Conventions.MaxNumberOfRequestsPerSession; }
/// <summary> /// Initializes a new instance of the <see cref="InMemoryFilesSessionOperations"/> class. /// </summary> protected InMemoryFilesSessionOperations( FilesStore filesStore, FilesSessionListeners listeners, Guid id) { Id = id; this.filesStore = filesStore; theListeners = listeners; MaxNumberOfRequestsPerSession = filesStore.Conventions.MaxNumberOfRequestsPerSession; UseOptimisticConcurrency = filesStore.Conventions.DefaultUseOptimisticConcurrency; }
/// <summary> /// Initializes a new instance of the <see cref="AsyncFilesSession"/> class. /// </summary> public AsyncFilesSession(FilesStore filesStore, IAsyncFilesCommands asyncFilesCommands, FilesSessionListeners listeners, Guid id) : base(filesStore, listeners, id) { Commands = asyncFilesCommands; filesStore.Changes().ForConflicts().Subscribe(this); }
public async Task CanMigrateAttachmentsToFileSystemOnDifferentServer() { using (var store = NewRemoteDocumentStore()) using (GetNewServer(8078)) using (var fsStore = new FilesStore() { Url = "http://localhost:8078", DefaultFileSystem = "RavenDB_2115" }.Initialize(true)) { var random = new Random(); var bytes = new byte[137]; random.NextBytes(bytes); for (int i = 0; i < 10; i++) { store.DatabaseCommands.PutAttachment("files/" + i, null, new MemoryStream(bytes), new RavenJObject()); } new CopyAttachmentsToFileSystem(new RavenConnectionStringOptions() { Url = store.Url, DefaultDatabase = store.DefaultDatabase }, new RavenConnectionStringOptions() { Url = "http://localhost:8078", }, "RavenDB_2115", false, 1).Execute(); Assert.Equal(10, store.DatabaseCommands.GetStatistics().CountOfAttachments); var browseResult = await fsStore.AsyncFilesCommands.BrowseAsync(); Assert.Equal(10, browseResult.Length); for (int i = 10; i < 20; i++) { store.DatabaseCommands.PutAttachment("files/" + i, null, new MemoryStream(bytes), new RavenJObject()); } new CopyAttachmentsToFileSystem(new RavenConnectionStringOptions() { Url = store.Url, DefaultDatabase = store.DefaultDatabase }, new RavenConnectionStringOptions() { Url = "http://localhost:8078", }, "RavenDB_2115", true, 3).Execute(); Assert.Equal(0, store.DatabaseCommands.GetStatistics().CountOfAttachments); browseResult = await fsStore.AsyncFilesCommands.BrowseAsync(); Assert.Equal(20, browseResult.Length); } }
private static IFilesStore CreateStore() { var filesStore = new FilesStore() { Url = String.Format("http://{0}:{1}", DocumentStoreHolder.Address, DocumentStoreHolder.Port), DefaultFileSystem = DocumentStoreHolder.DatabaseName + "FS" }.Initialize(); return filesStore; }
public override bool InitBackup() { parameters.ServerUrl = parameters.ServerUrl.TrimEnd('/'); try //precaution - to show error properly just in case { var serverUri = new Uri(parameters.ServerUrl); var serverHostname = serverUri.Scheme + Uri.SchemeDelimiter + serverUri.Host + ":" + serverUri.Port; store = new FilesStore { Url = serverHostname, DefaultFileSystem = parameters.Filesystem, ApiKey = parameters.ApiKey, Credentials = parameters.Credentials }; store.Initialize(); } catch (Exception exc) { Console.WriteLine(exc); try { store.Dispose(); } // ReSharper disable once EmptyGeneralCatchClause catch (Exception) { } return false; } var backupRequest = new { BackupLocation = parameters.BackupPath.Replace("\\", "\\\\"), }; var json = RavenJObject.FromObject(backupRequest).ToString(); var url = "/admin/backup"; if (parameters.Incremental) url += "?incremental=true"; try { using (var req = CreateRequest("/fs/" + parameters.Filesystem + url, "POST")) { req.WriteAsync(json).Wait(); Console.WriteLine("Sending json {0} to {1}", json, parameters.ServerUrl); var response = req.ReadResponseJson(); Console.WriteLine(response); } } catch (Exception exc) { Console.WriteLine(exc); return false; } return true; }
/// <summary> /// Initializes a new instance of the <see cref="AsyncFilesSession"/> class. /// </summary> public AsyncFilesSession(FilesStore filesStore, IAsyncFilesCommands asyncFilesCommands, FilesSessionListeners listeners, Guid id) : base(filesStore, listeners, id) { Commands = asyncFilesCommands; conflictCacheRemoval = filesStore.Changes(this.FileSystemName) .ForConflicts() .Subscribe(new FileConflictObserver(this)); }
/// <summary> /// Initializes a new instance of the <see cref="AsyncFilesSession"/> class. /// </summary> public AsyncFilesSession(FilesStore filesStore, IAsyncFilesCommands asyncFilesCommands, FilesSessionListeners listeners, Guid id) : base(filesStore, listeners, id) { Commands = asyncFilesCommands; conflictCacheRemoval = filesStore.Changes(this.FileSystemName) .ForConflicts() .Subscribe <ConflictNotification>(this.OnFileConflict); }
/// <summary> /// Initializes a new instance of the <see cref="AsyncFilesSession"/> class. /// </summary> public AsyncFilesSession(FilesStore filesStore, IAsyncFilesCommands asyncFilesCommands, FilesSessionListeners listeners, Guid id) : base(filesStore, listeners, id) { Commands = asyncFilesCommands; conflictCacheRemoval = filesStore.Changes(this.FileSystemName) .ForConflicts() .Subscribe<ConflictNotification>(this.OnFileConflict); }
public override async Task ImportData(SmugglerImportOptions<FilesConnectionStringOptions> importOptions) { if (importOptions.To == null) throw new ArgumentNullException("importOptions"); using (primaryStore = await CreateStore(importOptions.To)) using (documentStore = CreateDocumentStore(importOptions.To)) { Operations = new SmugglerRemoteFilesOperations(() => primaryStore, () => documentStore); await base.ImportData(importOptions); } }
public override async Task<ExportFilesResult> ExportData(SmugglerExportOptions<FilesConnectionStringOptions> exportOptions) { if (exportOptions.From == null) throw new ArgumentNullException("exportOptions"); using (primaryStore = await CreateStore(exportOptions.From)) using (documentStore = CreateDocumentStore(exportOptions.From)) { Operations = new SmugglerRemoteFilesOperations(() => primaryStore, () => documentStore); return await base.ExportData(exportOptions); } }
public void CredentialsAreLoadedFromConnectionString() { using (var store = new FilesStore() { ConnectionStringName = "RavenFS" }) { var credentials = (NetworkCredential)store.Credentials; Assert.Equal("local_user_test", credentials.UserName); Assert.Equal("local_user_test", credentials.Password); Assert.Equal(string.Empty, credentials.Domain); } }
protected async Task WaitForSynchronization(FilesStore store) { for (int i = 0; i < RetriesCount; i++) { using (var session = store.OpenAsyncSession()) { try { var file = await session.DownloadAsync(FileName); break; } catch { } Thread.Sleep(100); } } }
public override async Task Between(SmugglerBetweenOptions<FilesConnectionStringOptions> betweenOptions) { if (betweenOptions.From == null) throw new ArgumentNullException("betweenOptions.From"); if (betweenOptions.To == null) throw new ArgumentNullException("betweenOptions.To"); using (primaryStore = await CreateStore(betweenOptions.From)) using (secondaryStore = await CreateStore(betweenOptions.To)) using (documentStore = CreateDocumentStore(betweenOptions.To)) { Operations = new SmugglerBetweenRemoteFilesOperations(() => primaryStore, () => secondaryStore, () => documentStore); await base.Between(betweenOptions); } }
public RavenDbServer(InMemoryRavenConfiguration configuration) { this.configuration = configuration; documentStore = new DocumentStore { Conventions = { FailoverBehavior = FailoverBehavior.FailImmediately } }; filesStore = new FilesStore { Conventions = { FailoverBehavior = FailoverBehavior.FailImmediately } }; }
protected virtual IAsyncFilesCommands NewAsyncClient(int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null, ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null) { fileSystemName = NormalizeFileSystemName(fileSystemName); var server = CreateServer(Ports[index], fileSystemName: fileSystemName, enableAuthentication: enableAuthentication, requestedStorage: requestedStorage); server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl); var store = new FilesStore() { Url = server.Url, DefaultFileSystem = fileSystemName, Credentials = credentials, ApiKey = apiKey, }; store.Initialize(true); this.filesStores.Add(store); var client = store.AsyncFilesCommands; asyncCommandClients.Add(client); return client; }
internal static async Task<FilesStore> CreateStore(FilesConnectionStringOptions options) { var credentials = options.Credentials as NetworkCredential; if (credentials == null) { credentials = CredentialCache.DefaultNetworkCredentials; } else if ((String.IsNullOrWhiteSpace(credentials.UserName) || String.IsNullOrWhiteSpace(credentials.Password))) { credentials = CredentialCache.DefaultNetworkCredentials; } var store = new FilesStore { Credentials = credentials, ApiKey = options.ApiKey, Url = options.Url, DefaultFileSystem = options.DefaultFileSystem, }; store.Initialize(); await ValidateThatServerIsUpAndFilesystemExists(options, store); return store; }
internal static async Task ValidateThatServerIsUpAndFilesystemExists(FilesConnectionStringOptions server, FilesStore s) { var shouldDispose = false; try { var commands = !string.IsNullOrEmpty(server.DefaultFileSystem) ? s.AsyncFilesCommands.ForFileSystem(server.DefaultFileSystem) : s.AsyncFilesCommands; await commands.GetStatisticsAsync(); // check if file system exist } catch (Exception e) { shouldDispose = true; var responseException = e as ErrorResponseException; if (responseException != null && responseException.StatusCode == HttpStatusCode.ServiceUnavailable && responseException.Message.StartsWith("Could not find a file system named")) throw new SmugglerException( string.Format( "Smuggler does not support file system creation (file system '{0}' on server '{1}' must exist before running Smuggler).", server.DefaultFileSystem, s.Url), e); if (e.InnerException != null) { var webException = e.InnerException as WebException; if (webException != null) { throw new SmugglerException(string.Format("Smuggler encountered a connection problem: '{0}'.", webException.Message), webException); } } throw new SmugglerException(string.Format("Smuggler encountered a connection problem: '{0}'.", e.Message), e); } finally { if (shouldDispose) s.Dispose(); } }
protected virtual IAsyncFilesCommands NewAsyncClient(int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null, ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null, Action<RavenConfiguration> customConfig = null, string activeBundles = null, string dataDirectory = null, bool runInMemory = true) { fileSystemName = NormalizeFileSystemName(fileSystemName); var server = CreateServer(Ports[index], fileSystemName: fileSystemName, enableAuthentication: enableAuthentication, requestedStorage: requestedStorage, activeBundles: activeBundles, customConfig: customConfig, dataDirectory: dataDirectory, runInMemory: runInMemory); server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl); var store = new FilesStore() { Url = server.Url, DefaultFileSystem = fileSystemName, Credentials = credentials, ApiKey = apiKey, }; store.Initialize(true); filesStores.Add(store); var client = store.AsyncFilesCommands; asyncCommandClients.Add(client); return client; }
private static void RunRemoteFilesystemRestoreOperation(string backupLocation, string restoreLocation, string restoreFilesystemName, bool defrag, Uri uri, bool waitForRestore, int? timeout) { long operationId; using (var filesStore = new FilesStore { Url = uri.AbsoluteUri }.Initialize()) { operationId = filesStore.AsyncFilesCommands.Admin.StartRestore(new FilesystemRestoreRequest { BackupLocation = backupLocation, FilesystemLocation = restoreLocation, FilesystemName = restoreFilesystemName, Defrag = defrag, RestoreStartTimeout = timeout }).ResultUnwrap(); Console.WriteLine("Started restore operation from {0} on {1} server.", backupLocation, uri.AbsoluteUri); } if (waitForRestore) { using (var sysDbStore = new DocumentStore { Url = uri.AbsoluteUri }.Initialize()) { new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, operationId).WaitForCompletion(); Console.WriteLine("Completed restore operation from {0} on {1} server.", backupLocation, uri.AbsoluteUri); } } }
protected virtual IFilesStore NewStore( int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null, ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null) { fileSystemName = NormalizeFileSystemName(fileSystemName); var server = CreateRavenDbServer(Ports[index], fileSystemName: fileSystemName, enableAuthentication: enableAuthentication, requestedStorage: requestedStorage); var store = new FilesStore() { Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl), DefaultFileSystem = fileSystemName, Credentials = credentials, ApiKey = apiKey, }; store.Initialize(true); this.filesStores.Add(store); return store; }
/// <summary> /// Initializes a new instance of the <see cref="InMemoryFilesSessionOperations"/> class. /// </summary> protected InMemoryFilesSessionOperations( FilesStore filesStore, FilesSessionListeners listeners, Guid id) { this.Id = id; this.filesStore = filesStore; this.theListeners = listeners; this.MaxNumberOfRequestsPerSession = filesStore.Conventions.MaxNumberOfRequestsPerSession; }
public async Task after_failed_upload_file_should_not_exist() { const int fileSize = 1024*1024*2; // 2 MB const string fileName = "test.bin"; const int portIndex = 0; using (var initialStore = NewStore(portIndex)) { var alreadyReset = false; var port = 8070; var putInitialized = false; var uploaded = 0; using (new ProxyServer(ref port, Ports[portIndex]) { VetoTransfer = (totalRead, buffer) => { var numOfBytes = buffer.Count - buffer.Offset; var s = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count); if (s.StartsWith("PUT")) { putInitialized = true; uploaded = numOfBytes; return false; } if (putInitialized && alreadyReset == false) { uploaded += numOfBytes; if (uploaded > fileSize / 2) { alreadyReset = true; return true; } } return false; } }) { using (var storeUsingProxy = new FilesStore { Url = "http://localhost:" + port, DefaultFileSystem = initialStore.DefaultFileSystem }.Initialize()) { HttpRequestException hre = null; try { await storeUsingProxy.AsyncFilesCommands.UploadAsync(fileName, new MemoryStream(new byte[fileSize])); } catch (HttpRequestException e) { hre = e; } Assert.NotNull(hre); // the exception we caught was actually the client side exception because our proxy server forced the connection to be closed // wait a bit to make sure the actual request completed and the file has been marked as deleted on the server side Thread.Sleep(1000); var fileMetadata = await storeUsingProxy.AsyncFilesCommands.GetMetadataForAsync(fileName); Assert.Null(fileMetadata); } } } }
protected virtual FilesStore NewStore( int index = 0, bool fiddler = false, bool enableAuthentication = false, string apiKey = null, ICredentials credentials = null, string requestedStorage = null, [CallerMemberName] string fileSystemName = null, bool runInMemory = true, Action<RavenConfiguration> customConfig = null) { fileSystemName = NormalizeFileSystemName(fileSystemName); var server = CreateServer(Ports[index], fileSystemName: fileSystemName, enableAuthentication: enableAuthentication, customConfig: customConfig, requestedStorage: requestedStorage, runInMemory:runInMemory); server.Url = GetServerUrl(fiddler, server.SystemDatabase.ServerUrl); var store = new FilesStore { Url = server.Url, DefaultFileSystem = fileSystemName, Credentials = credentials, ApiKey = apiKey, }; store.Initialize(true); this.filesStores.Add(store); return store; }
public async Task CleanerStartupTaskShouldRemoveFileSystemsAfterIdleTimeout() { using (var server = GetNewServer()) using (var store = NewRemoteDocumentStore(ravenDbServer: server)) using (var fStore = new FilesStore { Url = store.Url, DefaultFileSystem = store.DefaultDatabase }.Initialize()) { await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(new FileSystemDocument { Id = "Northwind", Settings = { { Constants.FileSystem.DataDirectory, NewDataPath() } } }, "Northwind"); await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(new FileSystemDocument { Id = "Northwind2", Settings = { { Constants.FileSystem.DataDirectory, NewDataPath() } } }, "Northwind2"); await fStore.AsyncFilesCommands.Admin.CreateFileSystemAsync(new FileSystemDocument { Id = "Northwind3", Settings = { { Constants.FileSystem.DataDirectory, NewDataPath() } } }, "Northwind3"); await fStore .AsyncFilesCommands .ForFileSystem("Northwind2") .GetStatisticsAsync(); await fStore .AsyncFilesCommands .ForFileSystem("Northwind3") .GetStatisticsAsync(); Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind")); Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2")); server .Options .ServerStartupTasks .OfType<LiveTestResourceCleanerStartupTask>().First() .ExecuteCleanup(null); Assert.Null(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind")); Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2")); server.Server.Options.FileSystemLandlord.LastRecentlyUsed["Northwind2"] = DateTime.MinValue; server .Options .ServerStartupTasks .OfType<LiveTestResourceCleanerStartupTask>().First() .ExecuteCleanup(null); Assert.Null(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind2")); Assert.NotNull(store.DatabaseCommands.ForSystemDatabase().Get(Constants.FileSystem.Prefix + "Northwind3")); } }
protected override void ModifyStore(FilesStore store) { store.Conventions.FailoverBehavior = FailoverBehavior.FailImmediately; }
private async Task VerifyDump(FilesStore store, string backupPath, Action<FilesStore> action) { try { store.DefaultFileSystem += "-Verify"; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(store.DefaultFileSystem); bool incremental = false; var directory = new DirectoryInfo(backupPath); if ( directory.Exists ) incremental = true; var dumper = new SmugglerFilesApi { Options = { Incremental = incremental } }; await dumper.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = backupPath, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = store.DefaultFileSystem, } }); action(store); } catch (Exception e) { throw e.SimplifyException(); } }
public void SecurityForDatabasesCountersAndFileSystemsShouldBeConfiguredInOnePlaceAndWorkByName() { Authentication.EnableOnce(); using (var server = GetNewServer(enableAuthentication: true, runInMemory: false)) { server .SystemDatabase .Documents .Put( "Raven/Databases/DB1", null, RavenJObject.FromObject( new DatabaseDocument { Id = "DB1", Settings = { {"Raven/ActiveBundles", "PeriodicBackup"}, {"Raven/DataDir", "~\\Databases\\DB1"} } }), new RavenJObject(), null); server .SystemDatabase .Documents .Put( "Raven/ApiKeys/key1", null, RavenJObject.FromObject( new ApiKeyDefinition { Name = "key1", Secret = "ThisIsMySecret", Enabled = true, Databases = new List<ResourceAccess> { new ResourceAccess { TenantId = Constants.SystemDatabase, Admin = true }, new ResourceAccess { TenantId = "DB1", Admin = true } } }), new RavenJObject(), null); server .SystemDatabase .Documents .Put( "Raven/ApiKeys/key2", null, RavenJObject.FromObject( new ApiKeyDefinition { Name = "key2", Secret = "ThisIsMySecret2", Enabled = true, Databases = new List<ResourceAccess> { new ResourceAccess { TenantId = Constants.SystemDatabase, Admin = true }, new ResourceAccess { TenantId = "DB2", Admin = true } } }), new RavenJObject(), null); using (var store = new FilesStore { Url = server.Options.SystemDatabase.ServerUrl, DefaultFileSystem = "DB1", ApiKey = "key1/ThisIsMySecret" }.Initialize(ensureFileSystemExists: true)) { var files = AsyncHelpers.RunSync(() => store.AsyncFilesCommands.BrowseAsync()); } using (var store = new DocumentStore { Url = server.Options.SystemDatabase.ServerUrl, DefaultDatabase = "DB1", ApiKey = "key1/ThisIsMySecret" }.Initialize()) { var indexes = store.DatabaseCommands.GetIndexNames(0, 10); } using (var store = new FilesStore { Url = server.Options.SystemDatabase.ServerUrl, DefaultFileSystem = "DB1", ApiKey = "key2/ThisIsMySecret2" }.Initialize()) { var exception = Assert.Throws<ErrorResponseException>(() => AsyncHelpers.RunSync(() => store.AsyncFilesCommands.BrowseAsync())); Assert.Equal(HttpStatusCode.Forbidden, exception.StatusCode); } using (var store = new DocumentStore { Url = server.Options.SystemDatabase.ServerUrl, DefaultDatabase = "DB1", ApiKey = "key2/ThisIsMySecret2" }.Initialize()) { var exception = Assert.Throws<ErrorResponseException>(() => store.DatabaseCommands.GetIndexNames(0, 10)); Assert.Equal(HttpStatusCode.Forbidden, exception.StatusCode); } } }
protected override void ModifyStore(FilesStore store) { store.Conventions.FailoverBehavior = FailoverBehavior.ReadFromAllServers; }