public void HandleSystemDocumentChange(DocumentChangeNotification notification)
{
var key = notification.Key;
if (key.Equals(Constants.Versioning.RavenVersioningConfiguration, StringComparison.OrdinalIgnoreCase))
{
VersioningStorage = VersioningStorage.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info($"Versioning configuration was {(VersioningStorage != null ? "disabled" : "enabled")}");
}
}
else if (key.Equals(Constants.Expiration.ConfigurationDocumentKey, StringComparison.OrdinalIgnoreCase))
{
ExpiredDocumentsCleaner?.Dispose();
ExpiredDocumentsCleaner = ExpiredDocumentsCleaner.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info($"Expiration configuration was {(ExpiredDocumentsCleaner != null ? "enabled" : "disabled")}");
}
}
else if (key.Equals(Constants.PeriodicExport.ConfigurationDocumentKey, StringComparison.OrdinalIgnoreCase))
{
PeriodicExportRunner?.Dispose();
PeriodicExportRunner = PeriodicExportRunner.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info($"PeriodicExport configuration was {(PeriodicExportRunner != null ? "enabled" : "disabled")}");
}
}
}
private void InitializeFromDatabaseRecord(DatabaseRecord record)
{
if (record == null)
{
return;
}
ClientConfiguration = record.Client;
DocumentsStorage.RevisionsStorage.InitializeFromDatabaseRecord(record);
ExpiredDocumentsCleaner = ExpiredDocumentsCleaner.LoadConfigurations(this, record, ExpiredDocumentsCleaner);
PeriodicBackupRunner.UpdateConfigurations(record);
}
public void Dispose()
{
_database.Notifications.OnSystemDocumentChange -= HandleSystemDocumentChange;
var exceptionAggregator = new ExceptionAggregator(_logger, $"Could not dispose {nameof(BundleLoader)}");
exceptionAggregator.Execute(() =>
{
ExpiredDocumentsCleaner?.Dispose();
ExpiredDocumentsCleaner = null;
});
exceptionAggregator.Execute(() =>
{
PeriodicExportRunner?.Dispose();
PeriodicExportRunner = null;
});
exceptionAggregator.ThrowIfNeeded();
}
/// <summary>
/// Configure the database bundles if no changes has accord or when server start
/// </summary>
public void InitializeBundles()
{
DocumentsOperationContext context;
using (_database.DocumentsStorage.ContextPool.AllocateOperationContext(out context))
{
context.OpenReadTransaction();
var versioningConfiguration = _database.DocumentsStorage.Get(context,
Constants.Versioning.RavenVersioningConfiguration);
if (versioningConfiguration != null)
{
VersioningStorage = VersioningStorage.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info("Versioning configuration enabled");
}
}
var expirationConfiguration = _database.DocumentsStorage.Get(context,
Constants.Expiration.ConfigurationDocumentKey);
if (expirationConfiguration != null)
{
ExpiredDocumentsCleaner?.Dispose();
ExpiredDocumentsCleaner = ExpiredDocumentsCleaner.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info("Expiration configuration enabled");
}
}
var periodicExportConfiguration = _database.DocumentsStorage.Get(context,
Constants.PeriodicExport.ConfigurationDocumentKey);
if (periodicExportConfiguration != null)
{
PeriodicExportRunner?.Dispose();
PeriodicExportRunner = PeriodicExportRunner.LoadConfigurations(_database);
if (_logger.IsInfoEnabled)
{
_logger.Info("PeriodicExport configuration enabled");
}
}
}
}
public unsafe void Dispose()
{
if (_databaseShutdown.IsCancellationRequested)
{
return; // double dispose?
}
lock (this)
{
if (_databaseShutdown.IsCancellationRequested)
{
return; // double dispose?
}
//before we dispose of the database we take its latest info to be displayed in the studio
try
{
var databaseInfo = GenerateDatabaseInfo();
if (databaseInfo != null)
{
DatabaseInfoCache?.InsertDatabaseInfo(databaseInfo, Name);
}
}
catch (Exception e)
{
// if we encountered a catastrophic failure we might not be able to retrieve database info
if (_logger.IsInfoEnabled)
{
_logger.Info("Failed to generate and store database info", e);
}
}
_databaseShutdown.Cancel();
// we'll wait for 1 minute to drain all the requests
// from the database
var sp = Stopwatch.StartNew();
while (sp.ElapsedMilliseconds < 60 * 1000)
{
if (Interlocked.Read(ref _usages) == 0)
{
break;
}
if (_waitForUsagesOnDisposal.Wait(1000))
{
_waitForUsagesOnDisposal.Reset();
}
}
var exceptionAggregator = new ExceptionAggregator(_logger, $"Could not dispose {nameof(DocumentDatabase)} {Name}");
foreach (var connection in RunningTcpConnections)
{
exceptionAggregator.Execute(() =>
{
connection.Dispose();
});
}
exceptionAggregator.Execute(() =>
{
TxMerger?.Dispose();
});
if (_indexStoreTask != null)
{
exceptionAggregator.Execute(() =>
{
_indexStoreTask.Wait(DatabaseShutdown);
});
}
exceptionAggregator.Execute(() =>
{
IndexStore?.Dispose();
});
exceptionAggregator.Execute(() =>
{
ExpiredDocumentsCleaner?.Dispose();
});
exceptionAggregator.Execute(() =>
{
PeriodicBackupRunner?.Dispose();
});
exceptionAggregator.Execute(() =>
{
DocumentTombstoneCleaner?.Dispose();
});
exceptionAggregator.Execute(() =>
{
ReplicationLoader?.Dispose();
});
exceptionAggregator.Execute(() =>
{
EtlLoader?.Dispose();
});
exceptionAggregator.Execute(() =>
{
Operations?.Dispose(exceptionAggregator);
});
exceptionAggregator.Execute(() =>
{
NotificationCenter?.Dispose();
});
exceptionAggregator.Execute(() =>
{
SubscriptionStorage?.Dispose();
});
exceptionAggregator.Execute(() =>
{
ConfigurationStorage?.Dispose();
});
exceptionAggregator.Execute(() =>
{
DocumentsStorage?.Dispose();
});
exceptionAggregator.Execute(() =>
{
_databaseShutdown.Dispose();
});
exceptionAggregator.Execute(() =>
{
if (MasterKey == null)
{
return;
}
fixed(byte *pKey = MasterKey)
{
Sodium.sodium_memzero(pKey, (UIntPtr)MasterKey.Length);
}
});
exceptionAggregator.ThrowIfNeeded();
}
}