public void Unprotect(TimeSeriesDocument configDocument)
{
if (configDocument.SecuredSettings == null)
{
configDocument.SecuredSettings = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
return;
}
foreach (var prop in configDocument.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);
configDocument.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);
configDocument.SecuredSettings[prop.Key] = Constants.DataCouldNotBeDecrypted;
}
}
}
protected RavenConfiguration CreateConfiguration(
string tenantId,
TimeSeriesDocument document,
string folderPropName,
RavenConfiguration parentConfiguration)
{
var config = RavenConfiguration.CreateFrom(parentConfiguration);
SetupTenantConfiguration(config);
config.CustomizeValuesForTimeSeriesTenant(tenantId);
config.SetSetting(RavenConfiguration.GetKey(x => x.TimeSeries.DataDirectory), parentConfiguration.TimeSeries.DataDirectory);
foreach (var setting in document.Settings)
{
config.SetSetting(setting.Key, setting.Value);
}
Unprotect(document);
foreach (var securedSetting in document.SecuredSettings)
{
config.SetSetting(securedSetting.Key, securedSetting.Value);
}
config.SetSetting(folderPropName, config.GetSetting(folderPropName).ToFullPath(parentConfiguration.Core.DataDirectory));
config.SetSetting(RavenConfiguration.GetKey(x => x.Storage.JournalsStoragePath), config.GetSetting(RavenConfiguration.GetKey(x => x.Storage.JournalsStoragePath).ToFullPath(parentConfiguration.Core.DataDirectory)));
config.TimeSeriesName = tenantId;
config.Initialize();
config.CopyParentSettings(parentConfiguration);
return(config);
}
public BackupOperation(DocumentDatabase database, string backupSourceDirectory, string backupDestinationDirectory, StorageEnvironment env, bool incrementalBackup, TimeSeriesDocument timeSeriesDocument)
{
this.database = database;
this.backupDestinationDirectory = backupDestinationDirectory;
this.env = env;
this.incrementalBackup = incrementalBackup;
this.timeSeriesDocument = timeSeriesDocument;
this.backupSourceDirectory = backupSourceDirectory;
backupFilename = timeSeriesDocument.Id + ".Voron.Backup";
if (incrementalBackup)
{
PrepareForIncrementalBackup();
}
}
protected InMemoryRavenConfiguration CreateConfiguration(
string tenantId,
TimeSeriesDocument document,
string folderPropName,
InMemoryRavenConfiguration parentConfiguration)
{
var config = new InMemoryRavenConfiguration
{
Settings = new NameValueCollection(parentConfiguration.Settings),
};
SetupTenantConfiguration(config);
config.CustomizeValuesForTimeSeriesTenant(tenantId);
config.Settings[Constants.TimeSeries.DataDirectory] = parentConfiguration.TimeSeries.DataDirectory;
//config.Settings["Raven/StorageEngine"] = parentConfiguration.DefaultStorageTypeName;
//TODO: what time series dir path?
//config.Settings["Raven/TimeSeries/Storage"] = parentConfiguration.FileSystem.DefaultStorageTypeName;
foreach (var setting in document.Settings)
{
config.Settings[setting.Key] = setting.Value;
}
Unprotect(document);
foreach (var securedSetting in document.SecuredSettings)
{
config.Settings[securedSetting.Key] = securedSetting.Value;
}
config.Settings[folderPropName] = config.Settings[folderPropName].ToFullPath(parentConfiguration.DataDirectory);
//config.Settings["Raven/Esent/LogsPath"] = config.Settings["Raven/Esent/LogsPath"].ToFullPath(parentConfiguration.DataDirectory);
config.Settings[Constants.RavenTxJournalPath] = config.Settings[Constants.RavenTxJournalPath].ToFullPath(parentConfiguration.DataDirectory);
config.Settings["Raven/VirtualDir"] = config.Settings["Raven/VirtualDir"] + "/" + tenantId;
config.TimeSeriesName = tenantId;
config.Initialize();
config.CopyParentSettings(parentConfiguration);
return(config);
}
public void Protect(TimeSeriesDocument configDocument)
{
if (configDocument.SecuredSettings == null)
{
configDocument.SecuredSettings = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
return;
}
foreach (var prop in configDocument.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);
configDocument.SecuredSettings[prop.Key] = Convert.ToBase64String(protectedValue);
}
}
/// <summary>
/// Create new time series on the server.
/// </summary>
/// <param name="timeSeriesDocument">Settings for the time series. If null, default settings will be used, and the name specified in the client ctor will be used</param>
/// <param name="shouldUpdateIfExists">Indicates if time series should be updated if they exist.</param>
/// <param name="credentials">Credentials used for this operation.</param>
/// <param name="token">Cancellation token used for this operation.</param>
public async Task <TimeSeriesStore> CreateTimeSeriesAsync(TimeSeriesDocument timeSeriesDocument, bool shouldUpdateIfExists = false, OperationCredentials credentials = null, CancellationToken token = default(CancellationToken))
{
if (timeSeriesDocument == null)
{
throw new ArgumentNullException("timeSeriesDocument");
}
parent.AssertInitialized();
var timeSeriesName = timeSeriesDocument.Id.Replace(Constants.TimeSeries.Prefix, "");
var requestUri = parent.Url + "admin/ts/" + timeSeriesName;
if (shouldUpdateIfExists)
{
requestUri += "?update=true";
}
using (var request = parent.CreateHttpJsonRequest(requestUri, HttpMethods.Put))
{
try
{
await request.WriteAsync(RavenJObject.FromObject(timeSeriesDocument)).WithCancellation(token).ConfigureAwait(false);
}
catch (ErrorResponseException e)
{
if (e.StatusCode == HttpStatusCode.Conflict)
{
throw new InvalidOperationException("Cannot create time series with the name '" + timeSeriesName + "' because it already exists. Use CreateOrUpdateTimeSeriesAsync in case you want to update an existing time series", e);
}
throw;
}
}
return(new TimeSeriesStore
{
Name = timeSeriesName,
Url = parent.Url,
Credentials = credentials ?? parent.Credentials
});
}
public async Task Should_be_able_to_create_multiple_time_series()
{
var expectedClientNames = new[] { TimeSeriesName + "A", TimeSeriesName + "B", TimeSeriesName + "C" };
using (var store = NewRemoteTimeSeriesStore(createDefaultTimeSeries: false))
{
var defaultTimeSeriesDocument = new TimeSeriesDocument();
await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(expectedClientNames[0]));
await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(expectedClientNames[1]));
await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(expectedClientNames[2]));
var timeSeriesNames = await store.Admin.GetTimeSeriesNamesAsync();
Assert.Equal(expectedClientNames.Length, timeSeriesNames.Count());
foreach (var name in expectedClientNames)
{
Assert.Contains(name, timeSeriesNames);
}
}
}
