private static CreateSettingsModel ConfigureSettingsModel(NewDatabase newDatabase)
{
CreateSettingsModel bundlesModel;
bundlesModel = new CreateSettingsModel();
if (newDatabase.Quotas.IsChecked == true)
{
AddSection(bundlesModel, new QuotaSettingsSectionModel()
{
MaxSize = 50,
WarnSize = 45,
MaxDocs = 10000,
WarnDocs = 8000,
});
}
if (newDatabase.Versioning.IsChecked == true)
{
AddSection(bundlesModel, new VersioningSettingsSectionModel(true)
{
VersioningConfigurations =
{
new VersioningConfiguration()
{
Exclude = false,
Id = "Raven/Versioning/DefaultConfiguration",
MaxRevisions = 5
}
}
});
}
return(bundlesModel);
}
private static void AddSection(CreateSettingsModel bundlesModel, SettingsSectionModel section)
{
bundlesModel.Sections.Add(section);
if (bundlesModel.SelectedSection.Value == null)
{
bundlesModel.SelectedSection.Value = section;
}
}
private void HandleBundleAfterCreation(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 sqlReplicationSettings = settingsModel.GetSection <SqlReplicationSettingsSectionModel>();
if (sqlReplicationSettings != null)
{
sqlReplicationSettings.UpdateIds();
foreach (var sqlReplicationConfig in sqlReplicationSettings.SqlReplicationConfigs)
{
session.Store(sqlReplicationConfig);
}
}
var authorizationSection = settingsModel.GetSection <AuthorizationSettingsSectionModel>();
if (authorizationSection != null)
{
StoreAuthorizationData(authorizationSection, session);
}
session.SaveChangesAsync();
if (!string.IsNullOrEmpty(encryptionKey))
{
new ShowEncryptionMessage(encryptionKey).Show();
}
}
public override void Execute(object parameter)
{
new NewDatabase().ShowAsync()
.ContinueOnSuccessInTheUIThread(newDatabase =>
{
var databaseName = newDatabase.DbName.Text;
if (Path.GetInvalidPathChars().Any(databaseName.Contains))
{
throw new ArgumentException("Cannot create a database with invalid path characters: " + databaseName);
}
if (ApplicationModel.Current.Server.Value.Databases.Count(s => s == databaseName) != 0)
{
throw new ArgumentException("A database with the name " + databaseName + " already exists");
}
AssertValidName(databaseName);
var bundlesModel = new CreateSettingsModel();
var bundlesSettings = new List <ChildWindow>();
if (newDatabase.Encryption.IsChecked == true)
{
bundlesSettings.Add(new EncryptionSettings());
}
if (newDatabase.Quotas.IsChecked == true || newDatabase.Versioning.IsChecked == true)
{
bundlesModel = ConfigureSettingsModel(newDatabase);
var bundleView = new SettingsDialog()
{
DataContext = bundlesModel
};
var bundlesSettingsWindow = new ChildWindow()
{
Title = "Setup bundles",
Content = bundleView,
};
bundlesSettingsWindow.KeyDown += (sender, args) =>
{
if (args.Key == Key.Escape)
{
bundlesSettingsWindow.DialogResult = false;
}
};
bundlesSettings.Add(bundlesSettingsWindow);
}
new Wizard(bundlesSettings).StartAsync()
.ContinueOnSuccessInTheUIThread(bundlesData =>
{
ApplicationModel.Current.AddNotification(new Notification("Creating database: " + databaseName));
var settings = UpdateSettings(newDatabase, newDatabase, bundlesModel);
var securedSettings = UpdateSecuredSettings(bundlesData);
var databaseDocument = new DatabaseDocument
{
Id = newDatabase.DbName.Text,
Settings = settings,
SecuredSettings = securedSettings
};
string encryptionKey = null;
var encryptionSettings = bundlesData.FirstOrDefault(window => window is EncryptionSettings) as EncryptionSettings;
if (encryptionSettings != null)
{
encryptionKey = encryptionSettings.EncryptionKey.Text;
}
DatabaseCommands.CreateDatabaseAsync(databaseDocument).ContinueOnSuccess(
() => DatabaseCommands.ForDatabase(databaseName).EnsureSilverlightStartUpAsync())
.ContinueOnSuccessInTheUIThread(() =>
{
var model = parameter as DatabasesListModel;
if (model != null)
{
model.ForceTimerTicked();
}
ApplicationModel.Current.AddNotification(
new Notification("Database " + databaseName + " created"));
HandleBundleAfterCreation(bundlesModel, databaseName, encryptionKey);
ExecuteCommand(new ChangeDatabaseCommand(), databaseName);
})
.Catch();
});
})
.Catch();
}
private static Dictionary <string, string> UpdateSettings(NewDatabase newDatabase, NewDatabase bundles, CreateSettingsModel settingsData)
{
var settings = new Dictionary <string, string>
{
{
Constants.RavenDataDir, newDatabase.ShowAdvanced.IsChecked == true
? newDatabase.DbPath.Text
: Path.Combine("~", Path.Combine("Databases", newDatabase.DbName.Text))
},
{ Constants.ActiveBundles, string.Join(";", bundles.Bundles) }
};
if (!string.IsNullOrWhiteSpace(newDatabase.LogsPath.Text))
{
settings.Add(Constants.RavenLogsPath, newDatabase.LogsPath.Text);
}
if (!string.IsNullOrWhiteSpace(newDatabase.IndexPath.Text))
{
settings.Add(Constants.RavenIndexPath, newDatabase.IndexPath.Text);
}
var quotasData = settingsData.GetSection <QuotaSettingsSectionModel>();
if (quotasData != null)
{
settings[Constants.DocsHardLimit] = (quotasData.MaxDocs).ToString(CultureInfo.InvariantCulture);
settings[Constants.DocsSoftLimit] = (quotasData.WarnDocs).ToString(CultureInfo.InvariantCulture);
settings[Constants.SizeHardLimitInKB] = (quotasData.MaxSize * 1024).ToString(CultureInfo.InvariantCulture);
settings[Constants.SizeSoftLimitInKB] = (quotasData.WarnSize * 1024).ToString(CultureInfo.InvariantCulture);
}
return(settings);
}
