private Etag GetLastEtagFor(SqlReplicationStatus replicationStatus, SqlReplicationConfig sqlReplicationConfig)
{
var lastEtag = Etag.Empty;
var lastEtagHolder = replicationStatus.LastReplicatedEtags.FirstOrDefault(
x => string.Equals(sqlReplicationConfig.Name, x.Name, StringComparison.InvariantCultureIgnoreCase));
if (lastEtagHolder != null)
{
lastEtag = lastEtagHolder.LastDocEtag;
}
return(lastEtag);
}
private void SaveNewReplicationStatus(SqlReplicationStatus localReplicationStatus, Etag latestEtag)
{
int retries = 5;
while (retries > 0)
{
retries--;
try
{
var obj = RavenJObject.FromObject(localReplicationStatus);
Database.Put(ElasticsearchReplicationConstants.ElasticsearchReplicationStatus, null, obj, new RavenJObject(), null);
lastLatestEtag = latestEtag;
break;
}
catch (ConcurrencyException)
{
Thread.Sleep(50);
}
}
}
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
{
if (document.Destinations.Count != 0 && document.Destinations.Any(destination => destination.Disabled == false))
{
await CheckDestinations(document);
}
session.Store(document);
needToSaveChanges = true;
}
catch (Exception e)
{
ApplicationModel.Current.AddErrorNotification(e.GetBaseException());
}
}
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();
const string ravenSqlreplicationStatus = "Raven/SqlReplication/Status";
var status = await session.LoadAsync <SqlReplicationStatus>(ravenSqlreplicationStatus);
if (status == null)
{
status = new SqlReplicationStatus();
}
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, ravenSqlreplicationStatus);
}
foreach (var sqlReplicationConfig in sqlReplicationSettings.SqlReplicationConfigs)
{
var id = "Raven/SqlReplication/Configuration/" + sqlReplicationConfig.Name;
var config = await session.LoadAsync <SqlReplicationConfig>(id);
config = UpdateConfig(config, sqlReplicationConfig);
session.Store(config);
}
}
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();
}
foreach (var settingsSectionModel in settingsModel.Sections)
{
settingsSectionModel.MarkAsSaved();
}
ApplicationModel.Current.AddNotification(new Notification("Updated Settings for: " + databaseName));
}
private Etag GetLeastReplicatedEtag(IEnumerable <SqlReplicationConfig> config, SqlReplicationStatus localReplicationStatus)
{
Etag leastReplicatedEtag = null;
foreach (var sqlReplicationConfig in config)
{
var lastEtag = GetLastEtagFor(localReplicationStatus, sqlReplicationConfig);
if (leastReplicatedEtag == null)
{
leastReplicatedEtag = lastEtag;
}
else if (lastEtag.CompareTo(leastReplicatedEtag) < 0)
{
leastReplicatedEtag = lastEtag;
}
}
return(leastReplicatedEtag);
}
