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