public void ReplicateDatabaseCreation( DocumentDatabase database )
{
InstanceDescription self = null;
var replicationTargets = GetReplicationTargets(out self);
if (replicationTargets != null)
{
log.Info("Ensuring default database {0} is replicated from {2} at {3}",string.IsNullOrWhiteSpace(database.Name) ? "Default" : database.Name, self.Id, self.InternalUrl);
if (!string.IsNullOrWhiteSpace(database.Name))
{
EnsureDatabaseExists(replicationTargets,database.Name);
}
var documentId = new ReplicationDocument().Id;
var replicationDocument = new ReplicationDocument()
{
Destinations =
replicationTargets
.Select(i => new ReplicationDestination() { Url = GetReplicationUrl(database.Name,i) })
.ToList()
};
database.Put(documentId, null, RavenJObject.FromObject(replicationDocument), new RavenJObject(), null);
}
}
private void SetupDB(IDocumentStore store, string dbName, bool addReplicationTarget, string targetDbName)
{
DeleteDatabase(store, dbName, true);
var databaseDocument = new DatabaseDocument
{
Id = dbName,
Settings =
{
{ "Raven/ActiveBundles", "Replication" },
{ "Raven/DataDir", "~\\Databases\\" + dbName }
}
};
store.DatabaseCommands.EnsureDatabaseDocumentExists(databaseDocument);
if (addReplicationTarget)
{
var replicationDestination = new Raven.Abstractions.Replication.ReplicationDestination()
{
Url = SecondaryDocumentStore.Url,
TransitiveReplicationBehavior = TransitiveReplicationOptions.None,
Database = targetDbName
};
var newReplicationDocument = new Raven.Abstractions.Replication.ReplicationDocument()
{
Destinations = new List <ReplicationDestination>()
{
replicationDestination
}
};
using (var session = store.OpenSession(dbName))
{
session.Store(newReplicationDocument, @"Raven/Replication/Destinations");
session.SaveChanges();
}
}
new RavenDocumentsByEntityName().Execute(
store.DatabaseCommands.ForDatabase(dbName),
store.Conventions
);
new DocsIndex().Execute(
store.DatabaseCommands.ForDatabase(dbName),
store.Conventions
);
}
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);
}
});
}
private ReplicationInfoStatus[] CheckDestinations(ReplicationDocument replicationDocument)
{
var results = new ReplicationInfoStatus[replicationDocument.Destinations.Count];
Parallel.ForEach(replicationDocument.Destinations, (replicationDestination,state,i) =>
{
var url = replicationDestination.Url;
if (!url.ToLower().Contains("/databases/"))
{
url += "/databases/" + replicationDestination.Database;
}
var result = new ReplicationInfoStatus
{
Url = url,
Status = "Valid",
Code = (int)HttpStatusCode.OK
};
results[i] = result;
var ravenConnectionStringOptions = new RavenConnectionStringOptions
{
ApiKey = replicationDestination.ApiKey,
DefaultDatabase = replicationDestination.Database,
};
if (string.IsNullOrEmpty(replicationDestination.Username) == false)
{
ravenConnectionStringOptions.Credentials = new NetworkCredential(replicationDestination.Username,
replicationDestination.Password,
replicationDestination.Domain ?? string.Empty);
}
var request = requestFactory.Create(url + "/replication/info", "POST", ravenConnectionStringOptions);
try
{
request.ExecuteRequest();
}
catch (WebException e)
{
FillStatus(result, e);
}
});
return results;
}
public override void Execute(object parameter)
{
var databaseName = ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name;
var periodicBackup = settingsModel.GetSection<PeriodicBackupSettingsSectionModel>();
if (periodicBackup != null)
SavePeriodicBackup(databaseName, periodicBackup);
if(databaseName == Constants.SystemDatabase)
{
SaveApiKeys();
if(SaveWindowsAuth())
ApplicationModel.Current.Notifications.Add(new Notification("Api keys and Windows Authentication saved"));
else
{
ApplicationModel.Current.Notifications.Add(new Notification("Only Api keys where saved, something when wrong with Windows Authentication", NotificationLevel.Error));
}
return;
}
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseName);
var quotaSettings = settingsModel.GetSection<QuotaSettingsSectionModel>();
if (quotaSettings != null)
{
settingsModel.DatabaseDocument.Settings[Constants.SizeHardLimitInKB] =
(quotaSettings.MaxSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.SizeSoftLimitInKB] =
(quotaSettings.WarnSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsHardLimit] =
(quotaSettings.MaxDocs).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsSoftLimit] =
(quotaSettings.WarnDocs).ToString(CultureInfo.InvariantCulture);
if (settingsModel.DatabaseDocument.Id == null)
settingsModel.DatabaseDocument.Id = databaseName;
DatabaseCommands.CreateDatabaseAsync(settingsModel.DatabaseDocument);
}
var replicationSettings = settingsModel.GetSection<ReplicationSettingsSectionModel>();
if (replicationSettings != null)
{
session.LoadAsync<ReplicationDocument>("Raven/Replication/Destinations")
.ContinueOnSuccessInTheUIThread(document =>
{
if (document == null)
{
document = new ReplicationDocument();
}
document.Destinations.Clear();
foreach (var destination in replicationSettings.ReplicationDestinations
.Where(destination => !string.IsNullOrWhiteSpace(destination.Url)))
{
document.Destinations.Add(destination);
}
session.Store(document);
session.SaveChangesAsync().Catch();
})
.Catch();
}
var sqlReplicationSettings = settingsModel.GetSection<SqlReplicationSettingsSectionModel>();
if (sqlReplicationSettings != null)
{
if (sqlReplicationSettings.SqlReplicationConfigs.Any(config => config.Name == "Temp_Name") == false && sqlReplicationSettings.SqlReplicationConfigs.Any(config => string.IsNullOrWhiteSpace(config.Name)) == false)
{
var problemWithTable = false;
foreach (var sqlReplicationConfigModel in sqlReplicationSettings.SqlReplicationConfigs)
{
var hashset = new HashSet<string>();
foreach (var sqlReplicationTable in sqlReplicationConfigModel.SqlReplicationTables)
{
var exists = !hashset.Add(sqlReplicationTable.TableName);
if (string.IsNullOrWhiteSpace(sqlReplicationTable.DocumentKeyColumn) || string.IsNullOrWhiteSpace(sqlReplicationTable.TableName) || exists)
{
problemWithTable = true;
break;
}
}
if(problemWithTable)
break;
}
if (problemWithTable)
{
ApplicationModel.Current.AddNotification(new Notification("Sql Replicaiton settings were not saved, all tables must distinct names and have document keys", NotificationLevel.Error));
}
else
{
session.Advanced.LoadStartingWithAsync<SqlReplicationConfig>("Raven/SqlReplication/Configuration/")
.ContinueOnSuccessInTheUIThread(documents =>
{
sqlReplicationSettings.UpdateIds();
if (documents != null)
{
foreach (var sqlReplicationConfig in documents)
{
if (sqlReplicationSettings.SqlReplicationConfigs.All(config => config.Id != sqlReplicationConfig.Id))
{
session.Delete(sqlReplicationConfig);
}
}
}
foreach (var sqlReplicationConfig in sqlReplicationSettings.SqlReplicationConfigs)
{
sqlReplicationConfig.Id = "Raven/SqlReplication/Configuration/" + sqlReplicationConfig.Name;
session.Store(sqlReplicationConfig.ToSqlReplicationConfig());
}
session.SaveChangesAsync().Catch();
})
.Catch();
}
}
else
{
ApplicationModel.Current.AddNotification(new Notification("Sql Replicaiton settings not saved, all settings must have a name and it must be different from \"Temp_Name\"", NotificationLevel.Error));
}
}
var versioningSettings = settingsModel.GetSection<VersioningSettingsSectionModel>();
if (versioningSettings != null)
{
var versionsToDelete = versioningSettings.OriginalVersioningConfigurations
.Where(
originalVersioningConfiguration =>
versioningSettings.VersioningConfigurations.Contains(originalVersioningConfiguration) == false)
.ToList();
foreach (var versioningConfiguration in versionsToDelete)
{
DatabaseCommands.DeleteDocumentAsync(versioningConfiguration.Id);
}
foreach (var versioningConfiguration in versioningSettings.VersioningConfigurations)
{
if (versioningConfiguration.Id.StartsWith("Raven/Versioning/",StringComparison.InvariantCultureIgnoreCase) == false)
versioningConfiguration.Id = "Raven/Versioning/" + versioningConfiguration.Id;
session.Store(versioningConfiguration);
}
}
var authorizationSettings = settingsModel.GetSection<AuthorizationSettingsSectionModel>();
if (authorizationSettings != null)
{
var usersToDelete = authorizationSettings.OriginalAuthorizationUsers
.Where(authorizationUser => authorizationSettings.AuthorizationUsers.Contains(authorizationUser) == false)
.ToList();
foreach (var authorizationUser in usersToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationUser.Id);
}
var rolesToDelete = authorizationSettings.OriginalAuthorizationRoles
.Where(authorizationRole => authorizationSettings.AuthorizationRoles.Contains(authorizationRole) == false)
.ToList();
foreach (var authorizationRole in rolesToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationRole.Id);
}
foreach (var authorizationRole in authorizationSettings.AuthorizationRoles)
{
session.Store(authorizationRole);
}
foreach (var authorizationUser in authorizationSettings.AuthorizationUsers)
{
session.Store(authorizationUser);
}
}
session.SaveChangesAsync()
.ContinueOnSuccessInTheUIThread(() => ApplicationModel.Current.AddNotification(new Notification("Updated Settings for: " + databaseName)));
}
private void HendleBundleAfterCreation(CreateSettingsModel settingsModel, string databaseName, string encryptionKey)
{
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseName);
var versioningSection = settingsModel.GetSection<VersioningSettingsSectionModel>();
if (versioningSection != null)
StoreVersioningData(versioningSection.VersioningConfigurations, session);
var replicationSection = settingsModel.GetSection<ReplicationSettingsSectionModel>();
if (replicationSection != null)
{
var replicationDocument = new ReplicationDocument();
foreach (var replicationDestination in replicationSection.ReplicationDestinations
.Where(replicationDestination => !string.IsNullOrWhiteSpace(replicationDestination.Url) || !string.IsNullOrWhiteSpace(replicationDestination.ClientVisibleUrl)))
{
replicationDocument.Destinations.Add(replicationDestination);
}
session.Store(replicationDocument);
}
var authorizationSection = settingsModel.GetSection<AuthorizationSettingsSectionModel>();
if (authorizationSection != null)
StoreAuthorizationData(authorizationSection, session);
session.SaveChangesAsync();
if (!string.IsNullOrEmpty(encryptionKey))
new ShowEncryptionMessage(encryptionKey).Show();
}
protected override async Task ExecuteAsync(object parameter)
{
if(ApplicationModel.Current == null || ApplicationModel.Current.Server.Value == null || ApplicationModel.Current.Server.Value.SelectedDatabase.Value == null)
return;
if (settingsModel == null)
return;
var databaseName = ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name;
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseName);
if(databaseName == Constants.SystemDatabase)
{
var systemSession = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession();
await SaveApiKeys(systemSession);
var savedWinAuth = SaveWindowsAuth(systemSession);
if(needToSaveChanges)
await systemSession.SaveChangesAsync();
ApplicationModel.Current.Notifications.Add(savedWinAuth
? new Notification("Api keys and Windows Authentication saved")
: new Notification("Only Api keys where saved, something when wrong with Windows Authentication", NotificationLevel.Error));
return;
}
var periodicBackup = settingsModel.GetSection<PeriodicBackupSettingsSectionModel>();
if (periodicBackup != null)
await SavePeriodicBackup(periodicBackup, session);
var quotaSettings = settingsModel.GetSection<QuotaSettingsSectionModel>();
if (quotaSettings != null)
{
settingsModel.DatabaseDocument.Settings[Constants.SizeHardLimitInKB] =
(quotaSettings.MaxSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.SizeSoftLimitInKB] =
(quotaSettings.WarnSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsHardLimit] =
(quotaSettings.MaxDocs).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsSoftLimit] =
(quotaSettings.WarnDocs).ToString(CultureInfo.InvariantCulture);
if (settingsModel.DatabaseDocument.Id == null)
settingsModel.DatabaseDocument.Id = databaseName;
await DatabaseCommands.CreateDatabaseAsync(settingsModel.DatabaseDocument);
}
var replicationSettings = settingsModel.GetSection<ReplicationSettingsSectionModel>();
if (replicationSettings != null)
{
ReplicationDocument document;
try
{
document = await session.LoadAsync<ReplicationDocument>("Raven/Replication/Destinations") ?? new ReplicationDocument();
}
catch
{
document = new ReplicationDocument();
}
document.Destinations.Clear();
foreach (var destination in replicationSettings.ReplicationDestinations.Where(destination => !string.IsNullOrWhiteSpace(destination.Url)))
{
document.Destinations.Add(destination);
}
try
{
await CheckDestinations(document);
session.Store(document);
needToSaveChanges = true;
}
catch (Exception e)
{
ApplicationModel.Current.AddErrorNotification(e);
}
}
var scriptedSettings = settingsModel.GetSection<ScriptedIndexSettingsSectionModel>();
if (scriptedSettings != null)
{
scriptedSettings.StoreChanges();
foreach (var scriptedIndexResults in scriptedSettings.ScriptedIndexes)
{
if (scriptedIndexResults.Value != null)
{
scriptedIndexResults.Value.Id = ScriptedIndexResults.IdPrefix + scriptedIndexResults.Key;
session.Store(scriptedIndexResults.Value, scriptedIndexResults.Value.Id);
}
}
foreach (var indexName in scriptedSettings.DeletedIndexes)
{
var id = ScriptedIndexResults.IdPrefix + indexName;
await DatabaseCommands.DeleteDocumentAsync(id);
}
needToSaveChanges = true;
}
var sqlReplicationSettings = settingsModel.GetSection<SqlReplicationSettingsSectionModel>();
if (sqlReplicationSettings != null)
{
if (sqlReplicationSettings.SqlReplicationConfigs.Any(config => string.IsNullOrWhiteSpace(config.Name)) == false)
{
var problemWithTable = false;
foreach (var sqlReplicationConfigModel in sqlReplicationSettings.SqlReplicationConfigs)
{
var hashset = new HashSet<string>();
foreach (var sqlReplicationTable in sqlReplicationConfigModel.SqlReplicationTables)
{
var exists = !hashset.Add(sqlReplicationTable.TableName);
if (string.IsNullOrWhiteSpace(sqlReplicationTable.DocumentKeyColumn) ||
string.IsNullOrWhiteSpace(sqlReplicationTable.TableName) || exists)
{
problemWithTable = true;
break;
}
}
if (problemWithTable)
break;
}
if (problemWithTable)
{
ApplicationModel.Current.AddNotification(
new Notification(
"Sql Replication settings were not saved, all tables must distinct names and have document keys",
NotificationLevel.Error));
}
else
{
var hasChanges = new List<string>();
var documents = await session.Advanced.LoadStartingWithAsync<SqlReplicationConfig>("Raven/SqlReplication/Configuration/");
sqlReplicationSettings.UpdateIds();
if (documents != null)
{
hasChanges = sqlReplicationSettings.SqlReplicationConfigs.Where(config => HasChanges(config,
documents.FirstOrDefault(replicationConfig =>replicationConfig.Name == config.Name)))
.Select(config => config.Name).ToList();
foreach (var sqlReplicationConfig in documents)
{
if (sqlReplicationSettings.SqlReplicationConfigs.All(config => config.Id != sqlReplicationConfig.Id))
{
session.Delete(sqlReplicationConfig);
}
}
}
if (hasChanges != null && hasChanges.Count > 0)
{
var resetReplication = new ResetReplication(hasChanges);
await resetReplication.ShowAsync();
if (resetReplication.Selected.Count == 0)
return;
const string ravenSqlreplicationStatus = "Raven/SqlReplication/Status";
var status = await session.LoadAsync<SqlReplicationStatus>(ravenSqlreplicationStatus);
foreach (var name in resetReplication.Selected)
{
var lastReplicatedEtag = status.LastReplicatedEtags.FirstOrDefault(etag => etag.Name == name);
if (lastReplicatedEtag != null)
lastReplicatedEtag.LastDocEtag = Etag.Empty;
}
session.Store(status);
}
foreach (var sqlReplicationConfig in sqlReplicationSettings.SqlReplicationConfigs)
{
sqlReplicationConfig.Id = "Raven/SqlReplication/Configuration/" + sqlReplicationConfig.Name;
session.Store(sqlReplicationConfig.ToSqlReplicationConfig());
}
}
needToSaveChanges = true;
}
else
{
ApplicationModel.Current.AddNotification(
new Notification("Sql Replication settings not saved, all replications must have a name", NotificationLevel.Error));
}
}
var versioningSettings = settingsModel.GetSection<VersioningSettingsSectionModel>();
if (versioningSettings != null)
{
var versionsToDelete = versioningSettings.OriginalVersioningConfigurations
.Where(originalVersioningConfiguration =>
versioningSettings.VersioningConfigurations.Contains(originalVersioningConfiguration) == false)
.ToList();
foreach (var versioningConfiguration in versionsToDelete)
{
await DatabaseCommands.DeleteDocumentAsync(versioningConfiguration.Id);
}
foreach (var versioningConfiguration in versioningSettings.VersioningConfigurations)
{
if (versioningConfiguration.Id.StartsWith("Raven/Versioning/",StringComparison.OrdinalIgnoreCase) == false)
versioningConfiguration.Id = "Raven/Versioning/" + versioningConfiguration.Id;
session.Store(versioningConfiguration);
}
if (versioningSettings.DatabaseDocument != null)
await DatabaseCommands.CreateDatabaseAsync(versioningSettings.DatabaseDocument);
needToSaveChanges = true;
}
var authorizationSettings = settingsModel.GetSection<AuthorizationSettingsSectionModel>();
if (authorizationSettings != null)
{
var usersToDelete = authorizationSettings.OriginalAuthorizationUsers
.Where(authorizationUser => authorizationSettings.AuthorizationUsers.Contains(authorizationUser) == false)
.ToList();
foreach (var authorizationUser in usersToDelete)
{
await DatabaseCommands.DeleteDocumentAsync(authorizationUser.Id);
}
var rolesToDelete = authorizationSettings.OriginalAuthorizationRoles
.Where(authorizationRole => authorizationSettings.AuthorizationRoles.Contains(authorizationRole) == false)
.ToList();
foreach (var authorizationRole in rolesToDelete)
{
await DatabaseCommands.DeleteDocumentAsync(authorizationRole.Id);
}
foreach (var authorizationRole in authorizationSettings.AuthorizationRoles)
{
session.Store(authorizationRole);
}
foreach (var authorizationUser in authorizationSettings.AuthorizationUsers)
{
session.Store(authorizationUser);
}
needToSaveChanges = true;
}
if(needToSaveChanges)
await session.SaveChangesAsync();
ApplicationModel.Current.AddNotification(new Notification("Updated Settings for: " + databaseName));
}
private async Task CheckDestinations(ReplicationDocument replicationDocument)
{
var badReplication = new List<string>();
var request = ApplicationModel.Current.Server.Value.SelectedDatabase.Value
.AsyncDatabaseCommands
.CreateRequest(string.Format("/admin/replicationInfo").NoCache(), "POST");
await request.WriteAsync(RavenJObject.FromObject(replicationDocument).ToString());
var responseAsJson = await request.ReadResponseJsonAsync();
var replicationInfo = ApplicationModel.Current.Server.Value.DocumentStore.Conventions.CreateSerializer()
.Deserialize<ReplicationInfoStatus[]>(new RavenJTokenReader(responseAsJson));
foreach (var replicationInfoStatus in replicationInfo)
{
if (replicationInfoStatus.Status != "Valid")
{
badReplication.Add(replicationInfoStatus.Url + " - " + replicationInfoStatus.Code);
}
}
if (badReplication.Count != 0)
{
var mesage = "Some of the replications could not be reached:" + Environment.NewLine +
string.Join(Environment.NewLine, badReplication);
ApplicationModel.Current.Notifications.Add(new Notification(mesage, NotificationLevel.Warning));
}
}
private static void CreateReplication(IDocumentStore documentStore, string sourceDatabaseName, string destinationUrl, string destinationDatabaseName)
{
using (var session = documentStore.OpenSession(sourceDatabaseName))
{
var replicationDocument = new ReplicationDocument
{
Destinations = new List<ReplicationDestination>
{
new ReplicationDestination
{
Url = destinationUrl,
Database = destinationDatabaseName
}
}
};
session.Store(replicationDocument);
session.SaveChanges();
}
}
public override void Execute(object parameter)
{
var databaseName = ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name;
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseName);
var quotaSettings = settingsModel.GetSection<QuotaSettingsSectionModel>();
if (quotaSettings != null)
{
settingsModel.DatabaseDocument.Settings[Constants.SizeHardLimitInKB] =
(quotaSettings.MaxSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.SizeSoftLimitInKB] =
(quotaSettings.WarnSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsHardLimit] =
(quotaSettings.MaxDocs).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsSoftLimit] =
(quotaSettings.WarnDocs).ToString(CultureInfo.InvariantCulture);
if (settingsModel.DatabaseDocument.Id == null)
settingsModel.DatabaseDocument.Id = databaseName;
DatabaseCommands.CreateDatabaseAsync(settingsModel.DatabaseDocument);
}
var replicationSettings = settingsModel.GetSection<ReplicationSettingsSectionModel>();
if (replicationSettings != null)
{
session.LoadAsync<ReplicationDocument>("Raven/Replication/Destinations")
.ContinueOnSuccessInTheUIThread(document =>
{
if (document == null)
{
document = new ReplicationDocument();
}
document.Destinations.Clear();
foreach (var destination in replicationSettings.ReplicationDestinations
.Where(destination => !string.IsNullOrWhiteSpace(destination.Url) || !string.IsNullOrWhiteSpace(destination.ConnectionStringName)))
{
document.Destinations.Add(destination);
}
session.Store(document);
});
}
var versioningSettings = settingsModel.GetSection<VersioningSettingsSectionModel>();
if (versioningSettings != null)
{
var versionsToDelete = versioningSettings.OriginalVersioningConfigurations
.Where(
originalVersioningConfiguration =>
versioningSettings.VersioningConfigurations.Contains(originalVersioningConfiguration) == false)
.ToList();
foreach (var versioningConfiguration in versionsToDelete)
{
DatabaseCommands.DeleteDocumentAsync(versioningConfiguration.Id);
}
foreach (var versioningConfiguration in versioningSettings.VersioningConfigurations)
{
if (versioningConfiguration.Id.StartsWith("Raven/Versioning/",StringComparison.InvariantCultureIgnoreCase) == false)
versioningConfiguration.Id = "Raven/Versioning/" + versioningConfiguration.Id;
session.Store(versioningConfiguration);
}
}
var authorizationSettings = settingsModel.GetSection<AuthorizationSettingsSectionModel>();
if (authorizationSettings != null)
{
var usersToDelete = authorizationSettings.OriginalAuthorizationUsers
.Where(authorizationUser => authorizationSettings.AuthorizationUsers.Contains(authorizationUser) == false)
.ToList();
foreach (var authorizationUser in usersToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationUser.Id);
}
var rolesToDelete = authorizationSettings.OriginalAuthorizationRoles
.Where(authorizationRole => authorizationSettings.AuthorizationRoles.Contains(authorizationRole) == false)
.ToList();
foreach (var authorizationRole in rolesToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationRole.Id);
}
foreach (var authorizationRole in authorizationSettings.AuthorizationRoles)
{
session.Store(authorizationRole);
}
foreach (var authorizationUser in authorizationSettings.AuthorizationUsers)
{
session.Store(authorizationUser);
}
}
session.SaveChangesAsync()
.ContinueOnSuccessInTheUIThread(() => ApplicationModel.Current.AddNotification(new Notification("Updated Settings for: " + databaseName)));
}
private static void CreateReplication(IDocumentStore documentStore, string url)
{
using (var session = documentStore.OpenSession("Replication"))
{
var replicationDocument = new ReplicationDocument
{
Destinations = new List<ReplicationDestination>
{
new ReplicationDestination
{
Url = url,
Database = "Replication"
}
}
};
session.Store(replicationDocument);
session.SaveChanges();
}
}
public override void Execute(object parameter)
{
var databaseName = ApplicationModel.Current.Server.Value.SelectedDatabase.Value.Name;
var periodicBackup = settingsModel.GetSection<PeriodicBackupSettingsSectionModel>();
if (periodicBackup != null)
SavePeriodicBackup(databaseName, periodicBackup);
if(databaseName == Constants.SystemDatabase)
{
SaveApiKeys();
if(SaveWindowsAuth())
ApplicationModel.Current.Notifications.Add(new Notification("Api keys and Windows Authentication saved"));
else
{
ApplicationModel.Current.Notifications.Add(new Notification("Only Api keys where saved, something when wrong with Windows Authentication", NotificationLevel.Error));
}
return;
}
var session = ApplicationModel.Current.Server.Value.DocumentStore.OpenAsyncSession(databaseName);
var quotaSettings = settingsModel.GetSection<QuotaSettingsSectionModel>();
if (quotaSettings != null)
{
settingsModel.DatabaseDocument.Settings[Constants.SizeHardLimitInKB] =
(quotaSettings.MaxSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.SizeSoftLimitInKB] =
(quotaSettings.WarnSize * 1024).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsHardLimit] =
(quotaSettings.MaxDocs).ToString(CultureInfo.InvariantCulture);
settingsModel.DatabaseDocument.Settings[Constants.DocsSoftLimit] =
(quotaSettings.WarnDocs).ToString(CultureInfo.InvariantCulture);
if (settingsModel.DatabaseDocument.Id == null)
settingsModel.DatabaseDocument.Id = databaseName;
DatabaseCommands.CreateDatabaseAsync(settingsModel.DatabaseDocument);
}
var replicationSettings = settingsModel.GetSection<ReplicationSettingsSectionModel>();
if (replicationSettings != null)
{
session.LoadAsync<ReplicationDocument>("Raven/Replication/Destinations")
.ContinueOnSuccessInTheUIThread(document =>
{
if (document == null)
{
document = new ReplicationDocument();
}
document.Destinations.Clear();
foreach (var destination in replicationSettings.ReplicationDestinations
.Where(destination => !string.IsNullOrWhiteSpace(destination.Url)))
{
document.Destinations.Add(destination);
}
session.Store(document);
session.SaveChangesAsync().Catch();
})
.Catch();
}
var sqlReplicationSettings = settingsModel.GetSection<SqlReplicationSettingsSectionModel>();
if (sqlReplicationSettings != null)
{
if (sqlReplicationSettings.SqlReplicationConfigs.Any(config => config.Name == "Temp_Name") == false && sqlReplicationSettings.SqlReplicationConfigs.Any(config => string.IsNullOrWhiteSpace(config.Name)) == false)
{
var hasChanges = new List<string>();
session.Advanced.LoadStartingWithAsync<SqlReplicationConfigModel>("Raven/SqlReplication/Configuration/")
.ContinueOnSuccessInTheUIThread(documents =>
{
sqlReplicationSettings.UpdateIds();
if (documents != null)
{
hasChanges = sqlReplicationSettings.SqlReplicationConfigs.Where(config =>
HasChanges(config,
documents.FirstOrDefault(
replicationConfig =>
replicationConfig.Name ==
config.Name)))
.Select(config => config.Name).ToList();
foreach (var sqlReplicationConfig in documents)
{
if (sqlReplicationSettings.SqlReplicationConfigs.All(config => config.Id != sqlReplicationConfig.Id))
{
session.Delete(sqlReplicationConfig);
}
}
}
hasChanges.Add("test");
hasChanges.Add("test2");
if (hasChanges != null && hasChanges.Count > 0)
{
var resetReplication = new ResetReplication(hasChanges);
resetReplication.ShowAsync().ContinueOnSuccessInTheUIThread(() =>
{
if (resetReplication.Selected.Count == 0)
return;
const string ravenSqlreplicationStatus = "Raven/SqlReplication/Status";
session.LoadAsync<SqlReplicationStatus>(ravenSqlreplicationStatus).ContinueOnSuccess(status =>
{
foreach (var name in resetReplication.Selected)
{
var lastReplicatedEtag = status.LastReplicatedEtags.FirstOrDefault(etag => etag.Name == name);
if (lastReplicatedEtag != null)
lastReplicatedEtag.LastDocEtag = Etag.Empty;
}
session.Store(status);
session.SaveChangesAsync().Catch();
});
});
}
foreach (var sqlReplicationConfig in sqlReplicationSettings.SqlReplicationConfigs)
{
sqlReplicationConfig.Id = "Raven/SqlReplication/Configuration/" + sqlReplicationConfig.Name;
session.Store(sqlReplicationConfig);
}
session.SaveChangesAsync().Catch();
})
.Catch();
}
else
{
ApplicationModel.Current.AddNotification(new Notification("Sql Replicaiton settings not saved, all settings must have a name and it must be different from \"Temp_Name\"", NotificationLevel.Error));
}
}
var versioningSettings = settingsModel.GetSection<VersioningSettingsSectionModel>();
if (versioningSettings != null)
{
var versionsToDelete = versioningSettings.OriginalVersioningConfigurations
.Where(
originalVersioningConfiguration =>
versioningSettings.VersioningConfigurations.Contains(originalVersioningConfiguration) == false)
.ToList();
foreach (var versioningConfiguration in versionsToDelete)
{
DatabaseCommands.DeleteDocumentAsync(versioningConfiguration.Id);
}
foreach (var versioningConfiguration in versioningSettings.VersioningConfigurations)
{
if (versioningConfiguration.Id.StartsWith("Raven/Versioning/",StringComparison.OrdinalIgnoreCase) == false)
versioningConfiguration.Id = "Raven/Versioning/" + versioningConfiguration.Id;
session.Store(versioningConfiguration);
}
}
var authorizationSettings = settingsModel.GetSection<AuthorizationSettingsSectionModel>();
if (authorizationSettings != null)
{
var usersToDelete = authorizationSettings.OriginalAuthorizationUsers
.Where(authorizationUser => authorizationSettings.AuthorizationUsers.Contains(authorizationUser) == false)
.ToList();
foreach (var authorizationUser in usersToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationUser.Id);
}
var rolesToDelete = authorizationSettings.OriginalAuthorizationRoles
.Where(authorizationRole => authorizationSettings.AuthorizationRoles.Contains(authorizationRole) == false)
.ToList();
foreach (var authorizationRole in rolesToDelete)
{
DatabaseCommands.DeleteDocumentAsync(authorizationRole.Id);
}
foreach (var authorizationRole in authorizationSettings.AuthorizationRoles)
{
session.Store(authorizationRole);
}
foreach (var authorizationUser in authorizationSettings.AuthorizationUsers)
{
session.Store(authorizationUser);
}
}
session.SaveChangesAsync()
.ContinueOnSuccessInTheUIThread(() => ApplicationModel.Current.AddNotification(new Notification("Updated Settings for: " + databaseName)));
}
