private void RebuildDatabaseCacheIfSerializerChanged() { var serializer = ConfigurationManager.AppSettings[Nucache_Serializer_Key]; var currentSerializer = _keyValueService.GetValue(Nucache_Serializer_Key); if (currentSerializer == null) { currentSerializer = JSON_SERIALIZER_VALUE; } if (serializer == null) { serializer = JSON_SERIALIZER_VALUE; } if (serializer != currentSerializer) { _profilingLogger.Warn <NuCacheSerializerComponent>($"Database NuCache was serialized using {currentSerializer}. Currently configured NuCache serializer {serializer}. Rebuilding Nucache"); using (_profilingLogger.TraceDuration <NuCacheSerializerComponent>($"Rebuilding NuCache database with {currentSerializer} serializer")) { _service.Value.Rebuild(); _keyValueService.SetValue(Nucache_Serializer_Key, serializer); } } }
/// <summary> /// Executes. /// </summary> /// <param name="scopeProvider">A scope provider.</param> /// <param name="migrationBuilder">A migration builder.</param> /// <param name="keyValueService">A key-value service.</param> /// <param name="logger">A logger.</param> public void Execute(IScopeProvider scopeProvider, IMigrationBuilder migrationBuilder, IKeyValueService keyValueService, ILogger logger) { if (scopeProvider == null) { throw new ArgumentNullException(nameof(scopeProvider)); } if (migrationBuilder == null) { throw new ArgumentNullException(nameof(migrationBuilder)); } if (keyValueService == null) { throw new ArgumentNullException(nameof(keyValueService)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } var plan = Plan; using (var scope = scopeProvider.CreateScope()) { BeforeMigrations(scope, logger); // read current state var currentState = keyValueService.GetValue(StateValueKey); var forceState = false; if (currentState == null) { currentState = plan.InitialState; forceState = true; } // execute plan var state = plan.Execute(scope, currentState, migrationBuilder, logger); if (string.IsNullOrWhiteSpace(state)) { throw new Exception("Plan execution returned an invalid null or empty state."); } // save new state if (forceState) { keyValueService.SetValue(StateValueKey, state); } else if (currentState != state) { keyValueService.SetValue(StateValueKey, currentState, state); } AfterMigrations(scope, logger); scope.Complete(); } }
public TelemetryLevel GetConsentLevel() { var analyticsLevelString = _keyValueService.GetValue(Key); if (analyticsLevelString is null || Enum.TryParse(analyticsLevelString, out TelemetryLevel analyticsLevel) is false) { return(TelemetryLevel.Basic); } return(analyticsLevel); }
private EnterspeedUmbracoConfiguration GetConfigurationFromDatabase() { var savedConfigurationValue = _keyValueService.GetValue(_configurationDatabaseKey); if (string.IsNullOrWhiteSpace(savedConfigurationValue)) { return(null); } return(JsonConvert.DeserializeObject <EnterspeedUmbracoConfiguration>(savedConfigurationValue)); }
public void Initialize() { // a quick version of only run once. // for a more complete set of methods see Migrations samples var installed = keyValueService.GetValue(setupKey); if (installed == null || installed != "installed") { AddSection("admin", CustomSection.SectionAlias); keyValueService.SetValue(setupKey, "installed"); } }
public void RebuildDatabaseCacheIfSerializerChanged() { NuCacheSerializerType serializer = _nucacheSettings.Value.NuCacheSerializerType; var currentSerializerValue = _keyValueService.GetValue(NuCacheSerializerKey); if (!Enum.TryParse(currentSerializerValue, out NuCacheSerializerType currentSerializer) || serializer != currentSerializer) { _logger.LogWarning("Database NuCache was serialized using {CurrentSerializer}. Currently configured NuCache serializer {Serializer}. Rebuilding Nucache", currentSerializer, serializer); using (_profilingLogger.TraceDuration <NuCacheContentService>($"Rebuilding NuCache database with {serializer} serializer")) { Rebuild(); _keyValueService.SetValue(NuCacheSerializerKey, serializer.ToString()); } } }
/// <inheritdoc/> public void Handle(UmbracoApplicationStartingNotification notification) { if (notification.RuntimeLevel == Umbraco.Cms.Core.RuntimeLevel.Run) { var firstBootMigration = new FirstBootMigrationPlan(); var upgrader = new Upgrader(firstBootMigration); // this bit is done inside the upgrader.Execute method too, // but we don't want the extra three log messages during startup, // so we also check before we start var currentState = _keyValueService.GetValue(upgrader.StateValueKey); if (currentState == null || currentState != firstBootMigration.FinalState) { upgrader.Execute(_migrationPlanExecutor, _scopeProvider, _keyValueService); } } }
public HttpResponseMessage GetConfig() { var settings = _keyValueService.GetValue("redirectSettings_" + _key); RedirectSettings model; if (settings != null) { model = JsonConvert.DeserializeObject <RedirectSettings>(settings); } else { model = CreateEmptySettings(); } return(Request.CreateResponse(HttpStatusCode.OK, model)); }
/// <summary> /// Executes a db migration to install the UmbracoIdentity DB schema if required /// </summary> private void EnsureDatabaseSchema() { // migrate database schema var upgrader = new Upgrader(new UmbracoIdentityMigrationPlan()); // check if we need to execute // TODO: This logic should be better built into Umbraco (i.e. Package Migrations) // NOTE: The actual migration logic will not execute if the final migration step is detected from within upgrader.Execute, however getting to that point // allocates more objects than we need so it's actually slightly faster to do this up-front check first var stateValueKey = upgrader.StateValueKey; var currMigrationState = _keyValueService.GetValue(stateValueKey); var finalMigrationState = upgrader.Plan.FinalState; var needsUpgrade = currMigrationState != finalMigrationState; _logger.Debug <UmbracoIdentityComponent>("Final upgrade state is {FinalMigrationState}, database contains {DatabaseState}, needs upgrade? {NeedsUpgrade}", finalMigrationState, currMigrationState ?? "<null>", needsUpgrade); if (needsUpgrade) { upgrader.Execute(_scopeProvider, _migrationBuilder, _keyValueService, _logger); } }
public void CanExecute() { NullLoggerFactory loggerFactory = NullLoggerFactory.Instance; var database = new TestDatabase(); IDatabaseScope scope = Mock.Of <IDatabaseScope>(x => x.Notifications == Mock.Of <IScopedNotificationPublisher>()); Mock.Get(scope) .Setup(x => x.Database) .Returns(database); var sqlContext = new SqlContext(new SqlServerSyntaxProvider(Options.Create(new GlobalSettings())), DatabaseType.SQLCe, Mock.Of <IPocoDataFactory>()); var scopeProvider = new MigrationTests.TestScopeProvider(scope) { SqlContext = sqlContext }; IMigrationBuilder migrationBuilder = Mock.Of <IMigrationBuilder>(); Mock.Get(migrationBuilder) .Setup(x => x.Build(It.IsAny <Type>(), It.IsAny <IMigrationContext>())) .Returns <Type, IMigrationContext>((t, c) => { switch (t.Name) { case "DeleteRedirectUrlTable": return(new DeleteRedirectUrlTable(c)); case "NoopMigration": return(new NoopMigration(c)); default: throw new NotSupportedException(); } }); var executor = new MigrationPlanExecutor(scopeProvider, scopeProvider, loggerFactory, migrationBuilder); MigrationPlan plan = new MigrationPlan("default") .From(string.Empty) .To <DeleteRedirectUrlTable>("{4A9A1A8F-0DA1-4BCF-AD06-C19D79152E35}") .To <NoopMigration>("VERSION.33"); IKeyValueService kvs = Mock.Of <IKeyValueService>(); Mock.Get(kvs).Setup(x => x.GetValue(It.IsAny <string>())) .Returns <string>(k => k == "Umbraco.Tests.MigrationPlan" ? string.Empty : null); string state; using (IScope s = scopeProvider.CreateScope()) { // read current state var sourceState = kvs.GetValue("Umbraco.Tests.MigrationPlan") ?? string.Empty; // execute plan state = executor.Execute(plan, sourceState); // save new state kvs.SetValue("Umbraco.Tests.MigrationPlan", sourceState, state); s.Complete(); } Assert.AreEqual("VERSION.33", state); Assert.AreEqual(1, database.Operations.Count); Assert.AreEqual("DROP TABLE [umbracoRedirectUrl]", database.Operations[0].Sql); }