/// <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); }