/// <summary>
/// Initializes a new instance of the <see cref="CreatedPackageSchemaRepository" /> class.
/// </summary>
public CreatedPackageSchemaRepository(
IUmbracoDatabaseFactory umbracoDatabaseFactory,
IHostingEnvironment hostingEnvironment,
IOptions <GlobalSettings> globalSettings,
FileSystems fileSystems,
IEntityXmlSerializer serializer,
IDataTypeService dataTypeService,
ILocalizationService localizationService,
IFileService fileService,
IMediaService mediaService,
IMediaTypeService mediaTypeService,
IContentService contentService,
MediaFileManager mediaFileManager,
IMacroService macroService,
IContentTypeService contentTypeService,
string?mediaFolderPath = null,
string?tempFolderPath = null)
{
_umbracoDatabase = umbracoDatabaseFactory.CreateDatabase();
_hostingEnvironment = hostingEnvironment;
_fileSystems = fileSystems;
_serializer = serializer;
_dataTypeService = dataTypeService;
_localizationService = localizationService;
_fileService = fileService;
_mediaService = mediaService;
_mediaTypeService = mediaTypeService;
_contentService = contentService;
_mediaFileManager = mediaFileManager;
_macroService = macroService;
_contentTypeService = contentTypeService;
_xmlParser = new PackageDefinitionXmlParser();
_createdPackagesFolderPath = mediaFolderPath ?? Constants.SystemDirectories.CreatedPackages;
_tempFolderPath = tempFolderPath ?? Constants.SystemDirectories.TempData + "/PackageFiles";
}
private UmbracoDatabaseState GetUmbracoDatabaseState(IUmbracoDatabaseFactory databaseFactory)
{
try
{
if (!TryDbConnect(databaseFactory))
{
return(UmbracoDatabaseState.CannotConnect);
}
// no scope, no service - just directly accessing the database
using (var database = databaseFactory.CreateDatabase())
{
if (!database.IsUmbracoInstalled(_logger))
{
return(UmbracoDatabaseState.NotInstalled);
}
if (DoesUmbracoRequireUpgrade(database))
{
return(UmbracoDatabaseState.NeedsUpgrade);
}
}
return(UmbracoDatabaseState.Ok);
}
catch (Exception e)
{
// can connect to the database so cannot check the upgrade state... oops
_logger.Warn <RuntimeState>(e, "Could not check the upgrade state.");
// else it is bad enough that we want to throw
Reason = RuntimeLevelReason.BootFailedCannotCheckUpgradeState;
throw new BootFailedException("Could not check the upgrade state.", e);
}
}
public void GetDatabaseType()
{
using (var database = _databaseFactory.CreateDatabase())
{
var databaseType = database.DatabaseType;
Assert.AreEqual(DatabaseType.SQLCe, databaseType);
}
}
public void CreateDatabase() // FIXME: move to DatabaseBuilderTest!
{
var path = TestHelper.CurrentAssemblyDirectory;
AppDomain.CurrentDomain.SetData("DataDirectory", path);
// delete database file
// NOTE: using a custom db file for this test since we're re-using the one created with BaseDatabaseFactoryTest
var filePath = string.Concat(path, "\\DatabaseContextTests.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
// get the connectionstring settings from config
var settings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
// by default the conn string is: Datasource=|DataDirectory|UmbracoNPocoTests.sdf;Flush Interval=1;
// replace the SDF file with our own and create the sql ce database
var connString = settings.ConnectionString.Replace("UmbracoNPocoTests", "DatabaseContextTests");
using (var engine = new SqlCeEngine(connString))
{
engine.CreateDatabase();
}
// re-create the database factory and database context with proper connection string
_databaseFactory = new UmbracoDatabaseFactory(connString, Constants.DbProviderNames.SqlCe, _logger, new Lazy <IMapperCollection>(() => Mock.Of <IMapperCollection>()));
// create application context
//var appCtx = new ApplicationContext(
// _databaseFactory,
// new ServiceContext(migrationEntryService: Mock.Of<IMigrationEntryService>()),
// CacheHelper.CreateDisabledCacheHelper(),
// new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>()));
// create the umbraco database
DatabaseSchemaCreator schemaHelper;
using (var database = _databaseFactory.CreateDatabase())
using (var transaction = database.GetTransaction())
{
schemaHelper = new DatabaseSchemaCreator(database, _logger);
schemaHelper.InitializeDatabaseSchema();
transaction.Complete();
}
var umbracoNodeTable = schemaHelper.TableExists("umbracoNode");
var umbracoUserTable = schemaHelper.TableExists("umbracoUser");
var cmsTagsTable = schemaHelper.TableExists("cmsTags");
Assert.That(umbracoNodeTable, Is.True);
Assert.That(umbracoUserTable, Is.True);
Assert.That(cmsTagsTable, Is.True);
}
private UmbracoDatabaseState GetUmbracoDatabaseState(IUmbracoDatabaseFactory databaseFactory)
{
try
{
if (!TryDbConnect(databaseFactory))
{
return(UmbracoDatabaseState.CannotConnect);
}
// no scope, no service - just directly accessing the database
using (var database = databaseFactory.CreateDatabase())
{
if (!database.IsUmbracoInstalled())
{
return(UmbracoDatabaseState.NotInstalled);
}
// Make ONE SQL call to determine Umbraco upgrade vs package migrations state.
// All will be prefixed with the same key.
IReadOnlyDictionary <string, string> keyValues = database.GetFromKeyValueTable(Constants.Conventions.Migrations.KeyValuePrefix);
// This could need both an upgrade AND package migrations to execute but
// we will process them one at a time, first the upgrade, then the package migrations.
if (DoesUmbracoRequireUpgrade(keyValues))
{
return(UmbracoDatabaseState.NeedsUpgrade);
}
IReadOnlyList <string> packagesRequiringMigration = _packageMigrationState.GetPendingPackageMigrations(keyValues);
if (packagesRequiringMigration.Count > 0)
{
_startupState[PendingPacakgeMigrationsStateKey] = packagesRequiringMigration;
return(UmbracoDatabaseState.NeedsPackageMigration);
}
}
return(UmbracoDatabaseState.Ok);
}
catch (Exception e)
{
// can connect to the database so cannot check the upgrade state... oops
_logger.LogWarning(e, "Could not check the upgrade state.");
// else it is bad enough that we want to throw
Reason = RuntimeLevelReason.BootFailedCannotCheckUpgradeState;
BootFailedException = new BootFailedException("Could not check the upgrade state.", e);
throw BootFailedException;
}
}
protected virtual bool EnsureUmbracoUpgradeState(IUmbracoDatabaseFactory databaseFactory, ILogger logger)
{
var upgrader = new Upgrader(new UmbracoPlan());
var stateValueKey = upgrader.StateValueKey;
// no scope, no service - just directly accessing the database
using (var database = databaseFactory.CreateDatabase())
{
CurrentMigrationState = KeyValueService.GetValue(database, stateValueKey);
FinalMigrationState = upgrader.Plan.FinalState;
}
logger.Debug <RuntimeState>("Final upgrade state is {FinalMigrationState}, database contains {DatabaseState}", CurrentMigrationState, FinalMigrationState ?? "<null>");
return(CurrentMigrationState == FinalMigrationState);
}
private void RebuildSchemaFirstTime(TestDbMeta meta)
{
_databaseFactory.Configure(meta.ConnectionString, Constants.DatabaseProviders.SqlServer);
using (var database = (UmbracoDatabase)_databaseFactory.CreateDatabase())
{
database.LogCommands = true;
using (NPoco.ITransaction transaction = database.GetTransaction())
{
var schemaCreator = new DatabaseSchemaCreator(database, _loggerFactory.CreateLogger <DatabaseSchemaCreator>(), _loggerFactory, new UmbracoVersion(), Mock.Of <IEventAggregator>());
schemaCreator.InitializeDatabaseSchema();
transaction.Complete();
_cachedDatabaseInitCommands = database.Commands.ToArray();
}
}
}
private void DoUnattendedInstall(IUmbracoDatabaseFactory databaseFactory)
{
// unattended install is not enabled
if (RuntimeOptions.InstallUnattended == false)
{
return;
}
var localVersion = UmbracoVersion.LocalVersion; // the local, files, version
var codeVersion = _state.SemanticVersion; // the executing code version
// local version and code version is not equal, an unattended install cannot be performed
if (localVersion != codeVersion)
{
return;
}
// no connection string set
if (databaseFactory.Configured == false)
{
return;
}
// create SQL CE database if not existing and database provider is SQL CE
if (databaseFactory.ProviderName == Constants.DbProviderNames.SqlCe)
{
var dataSource = new SqlCeConnectionStringBuilder(databaseFactory.ConnectionString).DataSource;
var dbFilePath = dataSource.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
if (File.Exists(dbFilePath) == false)
{
var engine = new SqlCeEngine(databaseFactory.ConnectionString);
engine.CreateDatabase();
}
}
var tries = 5;
var connect = false;
for (var i = 0;;)
{
connect = databaseFactory.CanConnect;
if (connect || ++i == tries)
{
break;
}
Logger.Debug <CoreRuntime>("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
// could not connect to the database
if (connect == false)
{
return;
}
using (var database = databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled(Logger);
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return;
}
// all conditions fulfilled, do the install
Logger.Info <CoreRuntime>("Starting unattended install.");
try
{
database.BeginTransaction();
var creator = new DatabaseSchemaCreator(database, Logger);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
// Emit an event that unattended install completed
// Then this event can be listened for and create an unattended user
UnattendedInstalled?.Invoke(this, new UnattendedInstallEventArgs());
Logger.Info <CoreRuntime>("Unattended install completed.");
}
catch (Exception ex)
{
Logger.Error <CoreRuntime>(ex, "Error during unattended install.");
database.AbortTransaction();
throw new UnattendedInstallException(
"The database configuration failed with the following message: " + ex.Message
+ "\n Please check log file for additional information (can be found in '/App_Data/Logs/')");
}
}
}
private void DoUnattendedInstall(IUmbracoDatabaseFactory databaseFactory)
{
// unattended install is not enabled
if (RuntimeOptions.InstallUnattended == false)
{
return;
}
var localVersion = UmbracoVersion.LocalVersion; // the local, files, version
var codeVersion = _state.SemanticVersion; // the executing code version
// local version and code version is not equal, an unattended install cannot be performed
if (localVersion != codeVersion)
{
return;
}
// no connection string set
if (databaseFactory.Configured == false)
{
return;
}
var tries = 5;
var connect = false;
for (var i = 0;;)
{
connect = databaseFactory.CanConnect;
if (connect || ++i == tries)
{
break;
}
Logger.Debug <CoreRuntime>("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
// could not connect to the database
if (connect == false)
{
return;
}
using (var database = databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled(Logger);
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return;
}
// all conditions fulfilled, do the install
Logger.Info <CoreRuntime>("Starting unattended install.");
try
{
database.BeginTransaction();
var creator = new DatabaseSchemaCreator(database, Logger);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
Logger.Info <CoreRuntime>("Unattended install completed.");
}
catch (Exception ex)
{
Logger.Error <CoreRuntime>(ex, "Error during unattended install.");
database.AbortTransaction();
throw new UnattendedInstallException(
"The database configuration failed with the following message: " + ex.Message
+ "\n Please check log file for additional information (can be found in '/App_Data/Logs/')");
}
}
}
public Task HandleAsync(RuntimeUnattendedInstallNotification notification, CancellationToken cancellationToken)
{
// unattended install is not enabled
if (_unattendedSettings.Value.InstallUnattended == false)
{
return(Task.CompletedTask);
}
// no connection string set
if (_databaseFactory.Configured == false)
{
return(Task.CompletedTask);
}
_runtimeState.DetermineRuntimeLevel();
if (_runtimeState.Reason == RuntimeLevelReason.InstallMissingDatabase)
{
_dbProviderFactoryCreator.CreateDatabase(_databaseFactory.ProviderName, _databaseFactory.ConnectionString);
}
bool connect;
try
{
for (var i = 0; ;)
{
connect = _databaseFactory.CanConnect;
if (connect || ++i == 5)
{
break;
}
_logger.LogDebug("Could not immediately connect to database, trying again.");
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Error during unattended install.");
var innerException = new UnattendedInstallException("Unattended installation failed.", ex);
_runtimeState.Configure(Core.RuntimeLevel.BootFailed, Core.RuntimeLevelReason.BootFailedOnException, innerException);
return(Task.CompletedTask);
}
// could not connect to the database
if (connect == false)
{
return(Task.CompletedTask);
}
IUmbracoDatabase database = null;
try
{
using (database = _databaseFactory.CreateDatabase())
{
var hasUmbracoTables = database.IsUmbracoInstalled();
// database has umbraco tables, assume Umbraco is already installed
if (hasUmbracoTables)
{
return(Task.CompletedTask);
}
// all conditions fulfilled, do the install
_logger.LogInformation("Starting unattended install.");
database.BeginTransaction();
DatabaseSchemaCreator creator = _databaseSchemaCreatorFactory.Create(database);
creator.InitializeDatabaseSchema();
database.CompleteTransaction();
_logger.LogInformation("Unattended install completed.");
// Emit an event with EventAggregator that unattended install completed
// Then this event can be listened for and create an unattended user
_eventAggregator.Publish(new UnattendedInstallNotification());
}
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Error during unattended install.");
database?.AbortTransaction();
var innerException = new UnattendedInstallException(
"The database configuration failed."
+ "\n Please check log file for additional information (can be found in '/Umbraco/Data/Logs/')",
ex);
_runtimeState.Configure(Core.RuntimeLevel.BootFailed, Core.RuntimeLevelReason.BootFailedOnException, innerException);
}
return(Task.CompletedTask);
}