public BackupOperation(DocumentDatabase database, string backupSourceDirectory, string backupDestinationDirectory, bool incrementalBackup, DatabaseDocument databaseDocument) : base(database, backupSourceDirectory, backupDestinationDirectory, incrementalBackup, databaseDocument) { instance = ((TransactionalStorage) database.TransactionalStorage).Instance; backupConfigPath = Path.Combine(backupDestinationDirectory, "RavenDB.Backup"); }
private static int ReadSettingAsInt(DatabaseDocument document, string settingName) { var value = 0; if (document.Settings.ContainsKey(settingName)) int.TryParse(document.Settings[settingName], out value); return value; }
public async Task Execute(string[] args) { var documentStore = new DocumentStore { Url = uri.ToString(), } .Initialize(); var client = new RavenFileSystemClient(uri.ToString(), filesystem); Console.WriteLine("=== Available File Systems ==="); bool doesFileSystemExists = false; foreach (string name in await client.Admin.GetFileSystemsNames()) { Console.WriteLine(name); doesFileSystemExists |= name.ToLower() == filesystem; } if (!doesFileSystemExists) { var filesystemDocument = new DatabaseDocument() { Id = "Raven/FileSystems/" + filesystem }; filesystemDocument.Settings["Raven/FileSystem/DataDir"] = Path.Combine(filesystemLocation, filesystem); await client.Admin.CreateFileSystemAsync(filesystemDocument, filesystem); } Console.WriteLine(); foreach ( var file in directory.GetFiles()) { await client.UploadAsync(file.Name, file.OpenRead()); } }
public override void LoadFor(DatabaseDocument document) { var session = ApplicationModel.Current.Server.Value.DocumentStore .OpenAsyncSession(ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name); if (document.Settings.ContainsKey("Raven/AWSAccessKey") && document.SecuredSettings.ContainsKey("Raven/AWSSecretKey")) { AwsAccessKey = document.Settings["Raven/AWSAccessKey"]; AwsSecretKey = document.SecuredSettings["Raven/AWSSecretKey"]; } if (document.Settings.ContainsKey("Raven/AzureStorageAccount") && document.SecuredSettings.ContainsKey("Raven/AzureStorageKey")) { AzureStorageAccount = document.Settings["Raven/AzureStorageAccount"]; AzureStorageKey = document.SecuredSettings["Raven/AzureStorageKey"]; } session.LoadAsync<PeriodicBackupSetup>(PeriodicBackupSetup.RavenDocumentKey).ContinueWith(task => { PeriodicBackupSetup = task.Result; if (PeriodicBackupSetup == null) return; HasDocument = true; if (string.IsNullOrWhiteSpace(PeriodicBackupSetup.LocalFolderName) == false) SelectedOption.Value = 0; else if (string.IsNullOrWhiteSpace(PeriodicBackupSetup.GlacierVaultName) == false) SelectedOption.Value = 1; else if (string.IsNullOrWhiteSpace(PeriodicBackupSetup.S3BucketName) == false) SelectedOption.Value = 2; else if (string.IsNullOrWhiteSpace(PeriodicBackupSetup.AzureStorageContainer) == false) SelectedOption.Value = 3; OnPropertyChanged(() => HasDocument); OnPropertyChanged(() => PeriodicBackupSetup); }); }
public Task CreateDatabaseAsync(DatabaseDocument databaseDocument) { RavenJObject doc; var req = adminRequest.CreateDatabase(databaseDocument, out doc); return req.WriteAsync(doc.ToString(Formatting.Indented)); }
public HttpResponseMessage DatabasesGet(string id) { if (IsSystemDatabase(id)) { //fetch fake (empty) system database document var systemDatabaseDocument = new DatabaseDocument { Id = Constants.SystemDatabase }; return GetMessageWithObject(systemDatabaseDocument); } var docKey = "Raven/Databases/" + id; var document = Database.Documents.Get(docKey, null); if (document == null) return GetMessageWithString("Database " + id + " not found", HttpStatusCode.NotFound); var dbDoc = document.DataAsJson.JsonDeserialization<DatabaseDocument>(); dbDoc.Id = id; DatabasesLandlord.Unprotect(dbDoc); string activeBundles; if (dbDoc.Settings.TryGetValue(Constants.ActiveBundles, out activeBundles)) dbDoc.Settings[Constants.ActiveBundles] = BundlesHelper.ProcessActiveBundles(activeBundles); return GetMessageWithObject(dbDoc, HttpStatusCode.OK, document.Etag); }
public async Task CanRestoreAnEncryptedDatabase(string storageEngineTypeName) { IOExtensions.DeleteDirectory(@"~\Databases\Db1".ToFullPath()); IOExtensions.DeleteDirectory(@"~\Databases\Db2".ToFullPath()); using (var store = NewRemoteDocumentStore(requestedStorage: storageEngineTypeName, runInMemory: false)) { var db1 = new DatabaseDocument { Id = "Db1", Settings = new Dictionary<string, string> {{"Raven/DataDir", @"~\Databases\Db1"}}, SecuredSettings = new Dictionary<string, string> { {"Raven/Encryption/Key", "arHd5ENxwieUCAGkf4Rns8oPWx3f6npDgAowtIAPox0="}, {"Raven/Encryption/Algorithm", "System.Security.Cryptography.DESCryptoServiceProvider, mscorlib"}, {"Raven/Encryption/EncryptIndexes", "True"} }, }; await store.AsyncDatabaseCommands.GlobalAdmin.CreateDatabaseAsync(db1); using (var session = store.OpenAsyncSession("Db1")) { await session.StoreAsync(new User { Id = "users/1", Username = "******" }); await session.SaveChangesAsync(); } var backupFolderDb1 = NewDataPath("BackupFolderDb1"); await store.AsyncDatabaseCommands.ForDatabase("Db1").GlobalAdmin.StartBackupAsync(backupFolderDb1, db1,false ,"Db1"); WaitForBackup(store.DatabaseCommands.ForDatabase("Db1"), true); await store.AsyncDatabaseCommands.GlobalAdmin.StartRestoreAsync(new DatabaseRestoreRequest { BackupLocation = backupFolderDb1, DatabaseLocation = @"~\Databases\Db2", DatabaseName = "Db2" }); WaitForRestore(store.DatabaseCommands.ForSystemDatabase()); WaitForDocument(store.DatabaseCommands.ForSystemDatabase(), "Raven/Databases/Db2"); using (var session = store.OpenAsyncSession(Constants.SystemDatabase)) { var db2Settings = await session.LoadAsync<DatabaseDocument>("Raven/Databases/Db2"); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/Key"], db2Settings.SecuredSettings["Raven/Encryption/Key"]); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/Algorithm"], db2Settings.SecuredSettings["Raven/Encryption/Algorithm"]); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/EncryptIndexes"], db2Settings.SecuredSettings["Raven/Encryption/EncryptIndexes"]); } using (var session = store.OpenAsyncSession("Db2")) { var user = await session.LoadAsync<User>("users/1"); Assert.NotNull(user); Assert.Equal("fitzchak", user.Username); } } }
public async Task CreateDatabaseAsync(DatabaseDocument databaseDocument) { RavenJObject doc; using (var req = adminRequest.CreateDatabase(databaseDocument, out doc)) { await req.WriteAsync(doc.ToString(Formatting.Indented)).ConfigureAwait(false); } }
public BackupOperation(DocumentDatabase database, IPersistentSource persistentSource, string src, string to, DatabaseDocument databaseDocument) { this.database = database; this.persistentSource = persistentSource; this.src = src; this.to = to; this.databaseDocument = databaseDocument; }
private string Serialize(DatabaseDocument document) { using (var streamWriter = new StringWriter()) { serializer.Serialize(streamWriter, document); return streamWriter.ToString(); } }
public async Task CreateDatabaseAsync(DatabaseDocument databaseDocument, CancellationToken token = default (CancellationToken)) { RavenJObject doc; using (var req = adminRequest.CreateDatabase(databaseDocument, out doc)) { await req.WriteAsync(doc.ToString(Formatting.Indented)).WithCancellation(token).ConfigureAwait(false); } }
public BackupOperation(DocumentDatabase database, string src, string to, bool incrementalBackup, DatabaseDocument databaseDocument) { instance = ((TransactionalStorage)database.TransactionalStorage).Instance; this.src = src; this.to = to; this.incrementalBackup = incrementalBackup; this.databaseDocument = databaseDocument; this.database = database; }
public BackupOperation(DocumentDatabase database, string backupSourceDirectory, string backupDestinationDirectory, StorageEnvironment env, bool incrementalBackup, DatabaseDocument databaseDocument) : base(database, backupSourceDirectory, backupDestinationDirectory, incrementalBackup, databaseDocument) { if (env == null) throw new ArgumentNullException("env"); this.env = env; }
public HttpJsonRequest StartBackup(string backupLocation, DatabaseDocument databaseDocument, string databaseName, bool incremental) { if (databaseName == Constants.SystemDatabase) { return createRequestForSystemDatabase("/admin/backup", "POST"); } return createRequestForSystemDatabase("/databases/" + databaseName + "/admin/backup?incremental=" + incremental, "POST"); }
public override void LoadFor(DatabaseDocument document) { MaxSize = ReadSettingAsInt(document, Constants.SizeHardLimitInKB) / 1024; WarnSize = ReadSettingAsInt(document, Constants.SizeSoftLimitInKB) / 1024; MaxDocs = ReadSettingAsInt(document, Constants.DocsHardLimit); WarnDocs = ReadSettingAsInt(document, Constants.DocsSoftLimit); OnEverythingChanged(); }
public Task StartBackupAsync(string backupLocation, DatabaseDocument databaseDocument, bool incremental, string databaseName) { var request = adminRequest.StartBackup(backupLocation, databaseDocument, databaseName, incremental); return request.WriteAsync(RavenJObject.FromObject(new BackupRequest { BackupLocation = backupLocation, DatabaseDocument = databaseDocument })); }
private static long ReadSettingAsInt(DatabaseDocument document, string settingName) { long value; if (document.Settings.ContainsKey(settingName)) long.TryParse(document.Settings[settingName], out value); else value = long.MaxValue; return value; }
public HttpJsonRequest CreateDatabase(DatabaseDocument databaseDocument, out RavenJObject doc) { if (databaseDocument.Settings.ContainsKey("Raven/DataDir") == false) throw new InvalidOperationException("The Raven/DataDir setting is mandatory"); var dbname = databaseDocument.Id.Replace("Raven/Databases/", ""); MultiDatabase.AssertValidName(dbname); doc = RavenJObject.FromObject(databaseDocument); doc.Remove("Id"); return createRequestForSystemDatabase("/admin/databases/" + Uri.EscapeDataString(dbname), "PUT"); }
public void ShouldPreventFromChangingActiveBundles() { using (var store = NewDocumentStore()) { var dbDoc = new DatabaseDocument() { Settings = new Dictionary<string, string>() { { Constants.ActiveBundles, "" } } }; store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_1", null, RavenJObject.FromObject(dbDoc), new RavenJObject(), null); dbDoc.Settings[Constants.ActiveBundles] = "Replication"; Assert.Throws<OperationVetoedException>(() => store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_1", null, RavenJObject.FromObject(dbDoc), new RavenJObject(), null)); var dbDoc2 = new DatabaseDocument() { Settings = new Dictionary<string, string>() { { Constants.ActiveBundles, "Replication" } } }; store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_2", null, RavenJObject.FromObject(dbDoc2), new RavenJObject(), null); dbDoc2.Settings[Constants.ActiveBundles] = ""; Assert.Throws<OperationVetoedException>(() => store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_2", null, RavenJObject.FromObject(dbDoc2), new RavenJObject(), null)); var dbDoc3 = new DatabaseDocument() { Settings = new Dictionary<string, string>() { { Constants.ActiveBundles, "Replication" } } }; store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_3", null, RavenJObject.FromObject(dbDoc3), new RavenJObject(), null); dbDoc3.Settings[Constants.ActiveBundles] = "SqlReplication"; Assert.Throws<OperationVetoedException>(() => store.SystemDatabase.Documents.Put("Raven/Databases/RavenDB_1344_3", null, RavenJObject.FromObject(dbDoc3), new RavenJObject(), null)); } }
public override void LoadFor(DatabaseDocument document) { DatabaseEditor = new EditorDocument { Text = Serialize(document), Language = JsonLanguage, IsReadOnly = true }; CurrentDatabase = document.Id; OnPropertyChanged(() => DatabaseEditor); }
protected BaseBackupOperation(DocumentDatabase database, string backupSourceDirectory, string backupDestinationDirectory, bool incrementalBackup, DatabaseDocument databaseDocument) { if (databaseDocument == null) throw new ArgumentNullException("databaseDocument"); if (database == null) throw new ArgumentNullException("database"); if (backupSourceDirectory == null) throw new ArgumentNullException("backupSourceDirectory"); if (backupDestinationDirectory == null) throw new ArgumentNullException("backupDestinationDirectory"); this.database = database; this.backupSourceDirectory = backupSourceDirectory.ToFullPath(); this.backupDestinationDirectory = backupDestinationDirectory.ToFullPath(); this.incrementalBackup = incrementalBackup; this.databaseDocument = databaseDocument; }
public async Task CanRestoreAnEncryptedDatabase() { using (var store = NewRemoteDocumentStore(requestedStorage: "esent")) { var db1 = new DatabaseDocument { Id = "Db1", Settings = new Dictionary<string, string> {{"Raven/DataDir", @"~\Databases\Db1"}}, SecuredSettings = new Dictionary<string, string> { {"Raven/Encryption/Key", "arHd5ENxwieUCAGkf4Rns8oPWx3f6npDgAowtIAPox0="}, {"Raven/Encryption/Algorithm", "System.Security.Cryptography.DESCryptoServiceProvider, mscorlib"}, {"Raven/Encryption/EncryptIndexes", "True"} }, }; await store.AsyncDatabaseCommands.CreateDatabaseAsync(db1); using (var session = store.OpenAsyncSession("Db1")) { await session.StoreAsync(new User { Id = "users/1", Username = "******" }); await session.SaveChangesAsync(); } var backupFolderDb1 = NewDataPath("BackupFolderDb1"); await store.AsyncDatabaseCommands.ForDatabase("Db1").StartBackupAsync(backupFolderDb1, db1); WaitForBackup(store.DatabaseCommands.ForDatabase("Db1"), true); await store.AsyncDatabaseCommands.StartRestoreAsync(backupFolderDb1, @"~\Databases\Db2", "Db2"); WaitForRestore(store.DatabaseCommands); WaitForDocument(store.DatabaseCommands, "Raven/Databases/Db2"); using (var session = store.OpenAsyncSession()) { var db2Settings = await session.LoadAsync<DatabaseDocument>("Raven/Databases/Db2"); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/Key"], db2Settings.SecuredSettings["Raven/Encryption/Key"]); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/Algorithm"], db2Settings.SecuredSettings["Raven/Encryption/Algorithm"]); Assert.NotEqual(db1.SecuredSettings["Raven/Encryption/EncryptIndexes"], db2Settings.SecuredSettings["Raven/Encryption/EncryptIndexes"]); } using (var session = store.OpenAsyncSession("Db2")) { var user = await session.LoadAsync<User>("users/1"); Assert.NotNull(user); Assert.Equal("fitzchak", user.Username); } } }
private static void AsserDatabaseDocument(DatabaseDocument databaseDocument) { var activeBundles = databaseDocument.Settings[Constants.ActiveBundles].GetSemicolonSeparatedValues(); Assert.Contains("Replication", activeBundles); Assert.Contains("Quotas", activeBundles); Assert.Equal(ConfigurationManager.AppSettings["Raven/Bundles/LiveTest/Quotas/Size/HardLimitInKB"], databaseDocument.Settings[Constants.SizeHardLimitInKB]); Assert.Equal(ConfigurationManager.AppSettings["Raven/Bundles/LiveTest/Quotas/Size/SoftLimitInKB"], databaseDocument.Settings[Constants.SizeSoftLimitInKB]); Assert.Null(databaseDocument.Settings[Constants.DocsHardLimit]); Assert.Null(databaseDocument.Settings[Constants.DocsSoftLimit]); Assert.True(bool.Parse(databaseDocument.Settings["Raven/RunInMemory"])); Assert.Equal(InMemoryRavenConfiguration.VoronTypeName, databaseDocument.Settings["Raven/StorageEngine"]); }
public static void CreateDatabase(this IDatabaseCommands self, DatabaseDocument databaseDocument) { var serverClient = self.ForSystemDatabase() as ServerClient; if (serverClient == null) throw new InvalidOperationException("Ensuring database existence requires a Server Client but got: " + self); if(databaseDocument.Settings.ContainsKey("Raven/DataDir") == false) throw new InvalidOperationException("The Raven/DataDir setting is mandatory"); var doc = RavenJObject.FromObject(databaseDocument); doc.Remove("Id"); var req = serverClient.CreateRequest("PUT", "/admin/databases/" + Uri.EscapeDataString(databaseDocument.Id)); req.Write(doc.ToString(Formatting.Indented)); req.ExecuteRequest(); }
public override void LoadFor(DatabaseDocument _) { ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name) .LoadAsync<ReplicationDocument>("Raven/Replication/Destinations") .ContinueOnSuccessInTheUIThread(document => { if (document == null) return; ReplicationData = document; ReplicationDestinations.Clear(); foreach (var replicationDestination in ReplicationData.Destinations) { ReplicationDestinations.Add(replicationDestination); } }); }
public override void LoadFor(DatabaseDocument databaseDocument) { var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseDocument.Id); session.Advanced.LoadStartingWithAsync<VersioningConfiguration>("Raven/Versioning"). ContinueOnSuccessInTheUIThread(data => { VersioningConfigurations.Clear(); foreach (var versioningConfiguration in data) { VersioningConfigurations.Add(versioningConfiguration); } foreach (var versioningConfiguration in data) { OriginalVersioningConfigurations.Add(versioningConfiguration); } }); }
public HttpResponseMessage DatabasesGet(string id) { if (IsSystemDatabase(id)) { //fetch fake (empty) system database document var systemDatabaseDocument = new DatabaseDocument { Id = Constants.SystemDatabase }; return GetMessageWithObject(systemDatabaseDocument); } var docKey = "Raven/Databases/" + id; var document = Database.Documents.Get(docKey, null); if (document == null) return GetMessageWithString("Database " + id + " not found", HttpStatusCode.NotFound); var dbDoc = document.DataAsJson.JsonDeserialization<DatabaseDocument>(); dbDoc.Id = id; DatabasesLandlord.Unprotect(dbDoc); return GetMessageWithObject(dbDoc); }
public override void LoadFor(DatabaseDocument document) { var session = ApplicationModel.Current.Server.Value.DocumentStore .OpenAsyncSession(ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name); if (document.Settings.ContainsKey("Raven/AWSAccessKey") && document.SecuredSettings.ContainsKey("Raven/AWSSecretKey")) { AwsAccessKey = document.Settings["Raven/AWSAccessKey"]; AwsSecretKey = document.SecuredSettings["Raven/AWSSecretKey"]; } session.LoadAsync<PeriodicBackupSetup>(PeriodicBackupSetup.RavenDocumentKey).ContinueWith(task => { PeriodicBackupSetup = task.Result; if (PeriodicBackupSetup == null) return; HasDocument = true; OnPropertyChanged(() => HasDocument); OnPropertyChanged(() => PeriodicBackupSetup); }); }
public void Unprotect(DatabaseDocument databaseDocument) { if (databaseDocument.SecuredSettings == null) { databaseDocument.SecuredSettings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); return; } foreach (var prop in databaseDocument.SecuredSettings.ToList()) { if (prop.Value == null) continue; var bytes = Convert.FromBase64String(prop.Value); var entrophy = Encoding.UTF8.GetBytes(prop.Key); try { var unprotectedValue = ProtectedData.Unprotect(bytes, entrophy, DataProtectionScope.CurrentUser); databaseDocument.SecuredSettings[prop.Key] = Encoding.UTF8.GetString(unprotectedValue); } catch (Exception e) { logger.WarnException("Could not unprotect secured db data " + prop.Key + " setting the value to '<data could not be decrypted>'", e); databaseDocument.SecuredSettings[prop.Key] = "<data could not be decrypted>"; } } }
public void Protect(DatabaseDocument databaseDocument) { if (databaseDocument.SecuredSettings == null) { databaseDocument.SecuredSettings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); return; } foreach (var prop in databaseDocument.SecuredSettings.ToList()) { if (prop.Value == null) continue; var bytes = Encoding.UTF8.GetBytes(prop.Value); var entrophy = Encoding.UTF8.GetBytes(prop.Key); var protectedValue = ProtectedData.Protect(bytes, entrophy, DataProtectionScope.CurrentUser); databaseDocument.SecuredSettings[prop.Key] = Convert.ToBase64String(protectedValue); } }