public void FkCheckNoCheckTest()
{
var version = MsSqlVersion.MsSql2016;
var dd = new TestDatabaseFk();
dd.SetVersions(version.GetTypeMapper());
Init(version, dd);
var ddlReader = DataDefinitionReaderFactory.CreateDataDefinitionReader(
SqlExecuterTestAdapter.ConnectionStrings[version.UniqueName]
, SqlExecuterTestAdapter.GetContext(version), dd.GetSchemaNames().ToList());
var ddInDatabase = ddlReader.GetDatabaseDefinition();
var fk = dd.GetTable("Foreign").Properties.OfType <ForeignKey>().First();
Assert.AreEqual("true", fk.SqlEngineVersionSpecificProperties[version, "Nocheck"]);
fk.SqlEngineVersionSpecificProperties[version, "Nocheck"] = "false";
var comparer = new Comparer(SqlExecuterTestAdapter.GetContext(version));
var changes = comparer.Compare(ddInDatabase, dd);
_ = changes[0] as ForeignKeyChange;
_ = new DatabaseMigrator(SqlExecuterTestAdapter.GetExecuter(version.UniqueName), SqlGeneratorFactory.CreateMigrationGenerator(version, SqlExecuterTestAdapter.GetContext(version)));
// TODO change FK
// databaseMigrator.
}
protected void Application_Start()
{
NinjectContainer.RegisterAssembly();
DatabaseMigrator.UpdateDatabase();
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
public void Application_Start(object sender, EventArgs e)
{
System.Web.Helpers.AntiForgeryConfig.UniqueClaimTypeIdentifier = System.Security.Claims.ClaimTypes.Name;
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new CustomViewEngine());
XmlConfigurator.Configure();
var config = GlobalConfiguration.Configuration;
config.MapHttpAttributeRoutes();
config.EnsureInitialized();
LogManager.GetLogger(GetType()).Info("Application start!");
var dbMigrator = new DatabaseMigrator();
if (dbMigrator.ShouldRun)
{
if (!dbMigrator.CanConnectToDatabase())
{
throw new Exception("Cannot connect to the database. Please check your connection string and ensure the database exists.");
}
if (!dbMigrator.Run())
{
throw new Exception("Failed to Upgrade the Database using the pending Migrations. Please, see the Log file for further details.");
}
}
new AccessLogManager().Run();
RegisterRoutes(RouteTable.Routes);
RuntimePredicateBuilder.RequiredAssembliesPaths = new List <string>()
{
Server.MapPath("bin\\DSS2_SynchromodalityCapacityOptimisation.Backend.dll"),
Server.MapPath("bin\\DSS2_SynchromodalityCapacityOptimisation.Web.dll"),
Server.MapPath("bin\\zAppDev.DotNet.Framework.dll")
};
WebFormResources.ClearResources = true;
Utilities.InitXssEncoder();
}
public ActionResult Update(string password, string target = null)
{
if (password != WebAppSettings.DbMigrationSecret)
{
return(HttpNotFound());
}
try {
lock (_migrationLock) {
var migrator = new DatabaseMigrator <ApplicationDbContext, App.DataAccess.Migrations.Configuration>();
migrator.MigrateToLatestVersion(true, string.IsNullOrWhiteSpace(target) ? null : target);
return(Json(new {
Status = true,
Message =
$"Success in migrating DB. Target migration: {(string.IsNullOrWhiteSpace(target) ? "#LATEST#" : target)}"
}, JsonRequestBehavior.AllowGet));
}
} catch (Exception ex) {
_logger.LogError(ex);
return(Json(new {
Status = false,
Error = ex.Message,
ErrorInner = ex.InnerException?.Message
}, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Check sqlite database
/// </summary>
/// <returns>when database is compatible, return true</returns>
private bool CheckDatabase()
{
var ver = Database.ManagementCrud.DatabaseVersion;
if (String.IsNullOrEmpty(ver))
{
Database.ManagementCrud.DatabaseVersion = DbVersion;
}
else if (ver != DbVersion)
{
switch (ver)
{
// base version
case "1.0":
DatabaseMigrator.MigrateToVersionA();
DatabaseMigrator.MigrateToVersionB();
DatabaseMigrator.MigrateToVersionC();
Database.ManagementCrud.DatabaseVersion = DbVersion;
return(true);
case "A":
DatabaseMigrator.MigrateToVersionB();
DatabaseMigrator.MigrateToVersionC();
Database.ManagementCrud.DatabaseVersion = DbVersion;
return(true);
case "B":
DatabaseMigrator.MigrateToVersionC();
Database.ManagementCrud.DatabaseVersion = DbVersion;
return(true);
}
return(false);
}
return(true);
}
public void TearDown()
{
DatabaseMigrator.CleanUp();
MigrationsAssembly = null;
Logger = null;
DatabaseMigrator = null;
}
public static void TryApplyMigration <TDatabaseContext>(this TDatabaseContext context, Type initialMigrationType)
where TDatabaseContext : GeneralContext
{
var databaseMigrator = new DatabaseMigrator <TDatabaseContext>(context);
databaseMigrator.TryUpdateDatabase(initialMigrationType);
}
public void NewTableTest(SqlEngineVersion version)
{
_sqlExecuterTestAdapter.Check(version);
var dd = new TestDatabaseSimple();
_sqlExecuterTestAdapter.InitializeAndCreate(version.UniqueName, dd);
var context = new Context
{
Settings = TestHelper.GetDefaultTestSettings(version),
Logger = TestHelper.CreateLogger()
};
var migrationGenerator = SqlGeneratorFactory.CreateMigrationGenerator(version, context);
var executer = _sqlExecuterTestAdapter.GetExecuter(version.UniqueName);
var databaseMigrator = new DatabaseMigrator(executer, migrationGenerator);
var tableNew = new TableNew
{
SchemaAndTableName = "NewTableToMigrate"
};
((SqlTable)tableNew).AddInt32("Id", false).SetPK().SetIdentity();
new PrimaryKeyNamingDefaultStrategy().SetPrimaryKeyName(tableNew.Properties.OfType <PrimaryKey>().First());
((SqlTable)tableNew).AddNVarChar("Name", 100);
dd.AddTable(tableNew);
databaseMigrator.NewTable(tableNew);
}
public static void Configure()
{
if (Context.Database.Exists())
{
try
{
Context.Database.Delete();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
Console.WriteLine("Database deleted.");
}
DatabaseMigrator.Initialize();
var model = new User(); // TODO: пофиксить
Context.Users.Add(model); // TODO: пофиксить
Context.Entry(model).State = EntityState.Detached; // TODO: пофиксить
Console.WriteLine("Database created.");
}
public RoundhouseMigrationRunner(
string repository_path,
Environment environment,
KnownFolders known_folders,
FileSystemAccess file_system,
DatabaseMigrator database_migrator,
VersionResolver version_resolver,
bool silent,
bool dropping_the_database,
bool dont_create_the_database,
bool run_in_a_transaction,
bool use_simple_recovery)
{
this.known_folders = known_folders;
this.repository_path = repository_path;
this.environment = environment;
this.file_system = file_system;
this.database_migrator = database_migrator;
this.version_resolver = version_resolver;
this.silent = silent;
this.dropping_the_database = dropping_the_database;
this.dont_create_the_database = dont_create_the_database;
this.run_in_a_transaction = run_in_a_transaction;
this.use_simple_recovery = use_simple_recovery;
}
public RoundhouseMigrationRunner(
string repository_path,
Environment environment,
KnownFolders known_folders,
FileSystemAccess file_system,
DatabaseMigrator database_migrator,
VersionResolver version_resolver,
bool silent,
bool dropping_the_database,
bool dont_create_the_database,
bool run_in_a_transaction,
bool use_simple_recovery,
ConfigurationPropertyHolder configuration)
{
this.known_folders = known_folders;
this.repository_path = repository_path;
this.environment = environment;
this.file_system = file_system;
this.database_migrator = database_migrator;
this.version_resolver = version_resolver;
this.silent = silent;
this.dropping_the_database = dropping_the_database;
this.dont_create_the_database = dont_create_the_database;
this.run_in_a_transaction = run_in_a_transaction;
this.use_simple_recovery = use_simple_recovery;
this.configuration = configuration;
}
public void TestPushAndPopToBackgroundQueue()
{
var platformServicesFake = A.Fake <IPlatformServices>();
Device.PlatformServices = platformServicesFake;
DatabaseMigrator.Migrate(_connection, _migrationSkriptFolderPath);
var testSpotGuid = Guid.NewGuid();
var testLat = 48.45;
var testLng = 13.9167;
var result = BackgroundQueueService.PushWheaterRequestToBackgroundQueue(_connection, testSpotGuid, testLat, testLng).Result;
Assert.True(result != Guid.Empty);
var testSpotGuid2 = Guid.NewGuid();
var testLat2 = 48.45;
var testLng2 = 13.9167;
var result2 = BackgroundQueueService.PushWheaterRequestToBackgroundQueue(_connection, testSpotGuid2, testLat2, testLng2).Result;
Assert.True(result != Guid.Empty);
var model = BackgroundQueueService.PopWheaterRequestFromBackgroundQueue(_connection).Result;
Assert.Equal(model.ID_ElementReference.ToString(), testSpotGuid2.ToString());
var model2 = BackgroundQueueService.PopWheaterRequestFromBackgroundQueue(_connection, false).Result;
Assert.Equal(model2.ID_ElementReference.ToString(), testSpotGuid.ToString());
}
public void TestRemoveFromBackgroundQueue()
{
var platformServicesFake = A.Fake <IPlatformServices>();
Device.PlatformServices = platformServicesFake;
DatabaseMigrator.Migrate(_connection, _migrationSkriptFolderPath);
var deleteAll = BackgroundQueueService.EmptyQueue(_connection).Result;
Assert.True(deleteAll);
var testSpotGuid = Guid.NewGuid();
var testLat = 48.45;
var testLng = 13.9167;
var result = BackgroundQueueService.PushWheaterRequestToBackgroundQueue(_connection, testSpotGuid, testLat, testLng).Result;
Assert.True(result != Guid.Empty);
var model = BackgroundQueueService.PopWheaterRequestFromBackgroundQueue(_connection).Result;
bool res = BackgroundQueueService.RemoveElementFromQueue(_connection, model).Result;
Assert.True(res);
model = BackgroundQueueService.PopWheaterRequestFromBackgroundQueue(_connection).Result;
Assert.Null(model);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void run(final org.neo4j.io.fs.FileSystemAbstraction fs, final java.io.File storeDirectory, org.neo4j.kernel.configuration.Config config, org.neo4j.logging.LogProvider userLogProvider) throws Exception
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public static void Run(FileSystemAbstraction fs, File storeDirectory, Config config, LogProvider userLogProvider)
{
StoreLogService logService = StoreLogService.withUserLogProvider(userLogProvider).withInternalLog(config.Get(store_internal_log_path)).build(fs);
VisibleMigrationProgressMonitor progressMonitor = new VisibleMigrationProgressMonitor(logService.GetUserLog(typeof(StoreMigration)));
LifeSupport life = new LifeSupport();
life.Add(logService);
// Add participants from kernel extensions...
DefaultExplicitIndexProvider migrationIndexProvider = new DefaultExplicitIndexProvider();
Log log = userLogProvider.GetLog(typeof(StoreMigration));
JobScheduler jobScheduler = JobSchedulerFactory.createInitialisedScheduler();
try
{
using (PageCache pageCache = createPageCache(fs, config, jobScheduler))
{
Dependencies deps = new Dependencies();
Monitors monitors = new Monitors();
deps.SatisfyDependencies(fs, config, migrationIndexProvider, pageCache, logService, monitors, RecoveryCleanupWorkCollector.immediate());
KernelContext kernelContext = new SimpleKernelContext(storeDirectory, DatabaseInfo.UNKNOWN, deps);
DatabaseKernelExtensions kernelExtensions = life.Add(new DatabaseKernelExtensions(kernelContext, GraphDatabaseDependencies.newDependencies().kernelExtensions(), deps, ignore()));
DatabaseLayout databaseLayout = DatabaseLayout.of(storeDirectory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, new VersionAwareLogEntryReader <Org.Neo4j.Kernel.impl.transaction.log.ReadableClosablePositionAwareChannel>(), monitors);
DefaultIndexProviderMap indexProviderMap = life.Add(new DefaultIndexProviderMap(kernelExtensions, config));
// Add the kernel store migrator
life.Start();
long startTime = DateTimeHelper.CurrentUnixTimeMillis();
DatabaseMigrator migrator = new DatabaseMigrator(progressMonitor, fs, config, logService, indexProviderMap, migrationIndexProvider, pageCache, RecordFormatSelector.selectForConfig(config, userLogProvider), tailScanner, jobScheduler);
migrator.Migrate(databaseLayout);
// Append checkpoint so the last log entry will have the latest version
AppendCheckpoint(logFiles, tailScanner);
long duration = DateTimeHelper.CurrentUnixTimeMillis() - startTime;
log.Info(format("Migration completed in %d s%n", duration / 1000));
}
}
catch (Exception e)
{
throw new StoreUpgrader.UnableToUpgradeException("Failure during upgrade", e);
}
finally
{
life.Shutdown();
jobScheduler.close();
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
Settings.ConnectionString = ConfigurationManager.AppSettings["ConnectionString"];
DatabaseMigrator.MigrateDatabase();
ServiceFactory.Bootstrap();
}
public DbController(PawnShopDbContext db, UserManager <User> userManager, RoleManager <Role> roleManager, DatabaseMigrator migrator)
{
_roleManager = roleManager;
_db = db.GuardIsNotNull(nameof(db));
_userManager = userManager.GuardIsNotNull(nameof(userManager));
_roleManager = roleManager.GuardIsNotNull(nameof(roleManager));
_migrator = migrator.GuardIsNotNull(nameof(migrator));
}
private void MigrateToVersion(long version, Assembly assembly)
{
var log = new StringBuilder();
var logger = new StringLogger(log);
var db = new DatabaseMigrator(logger, false, "SqlServer", version, true);
db.Execute(Settings, assembly);
}
private void InitApp()
{
var isMigrationNeeded = DatabaseMigrator.CheckForMigration(this);
if (isMigrationNeeded)
{
DatabaseMigrator.ApplyMigration(this);
}
}
public virtual void Arrange()
{
ConnectionString = IntegrationTest.Configuration.GetConnectionString("FasTnT.Database");
Connection = new NpgsqlConnection(ConnectionString);
Connection.Open();
DatabaseMigrator.Migrate(ConnectionString);
Client = IntegrationTest.Client;
}
public void ReadRoundhouseTimeoutValue(string configValue, int expectedResult)
{
// Arrange
var configRepoMock = new Mock <IConfigurationRepository>();
configRepoMock.Setup(m => m.ReadConfigurationValue(ConfigurationKeys.Section, ConfigurationKeys.RoundhouseTimeoutSeconds)).Returns(configValue);
var config = DatabaseMigrator.ReadRoundhouseTimeoutValue(configRepoMock.Object);
Assert.That(config, Is.EqualTo(expectedResult));
}
private static void DropAndCreateDatabase(IConfiguration configuration)
{
var connectionString = SQLiteConnectionStringParser.Parse(configuration.GetConnectionString("DefaultConnection"));
var connectionFactory = new DefaultConnectionFactory(connectionString);
var connectionValues = connectionString.ToNameValueCollection();
var dbFilePath = connectionValues.Get(SQLiteConnectionStringKeys.DataSource);
File.Delete(dbFilePath);
DatabaseMigrator.Migrate(connectionFactory);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
//初始化实体
ServiceInitializer.RegisterEntities();
DatabaseMigrator <EfDbContext, EfConfiguration> .MigrateDatabase();
RegisterService();
}
static int Main(string[] args)
{
// :Configure: Put this somewhere in your service startup passing your connection string.
using var migrator = new DatabaseMigrator(new ConsoleStartupLogger());
var schemaChangingScripts = migrator.PerformMigrations(@"Server=.\SQLExpress;Trusted_Connection=Yes;Database=MigrationDatabase");
schemaChangingScripts?.SchemaChangingScripts.ForEach(s => Console.WriteLine($"Encountered schema changing script: {Environment.NewLine}{s}"));
Console.WriteLine("Done with migrations.");
Console.ReadLine();
return(0);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
var migrator = new DatabaseMigrator();
migrator.Update();
_container = new WindsorContainer().Install(FromAssembly.This());
ControllerBuilder.Current.SetControllerFactory(new ControllerFactory(_container.Kernel));
}
async public Task ShouldThrowMigrationException(int sqlExceptionNumber)
{
using AutoMock mock = AutoMock.GetLoose();
mock.Mock <IMigrateAsyncWrapper>()
.Setup(x => x.MigrateAsync(It.IsAny <DatabaseFacade>()))
.Throws(new SqlExceptionBuilder()
.WithErrorNumber(sqlExceptionNumber)
.Build());
DatabaseMigrator migrator = mock.Create <DatabaseMigrator>();
await Assert.ThrowsAsync <MigrationException>(() => migrator.EnsureMigrated());
}
static SliceFixture()
{
connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
DatabaseMigrator databaseMigrator = new DatabaseMigrator();
databaseMigrator.Migrate(connectionString);
checkpoint = new Checkpoint();
container = new Container();
container.Configure(cfg =>
{
cfg.AddRegistry <DomainRegistry>();
});
}
public void Configure()
{
BsonSerializer.RegisterSerializer(typeof(DateTime), new DateTimeSerializer(DateTimeKind.Local));
BsonClassMap.RegisterClassMap <PDV>();
BsonClassMap.RegisterClassMap <NaturalPeople>();
BsonClassMap.RegisterClassMap <LegalPeople>();
if (!DataBaseExists())
{
DatabaseMigrator.Migrate(this);
}
}
public static IServiceCollection AddEpcisPersistence(this IServiceCollection services, string connectionString)
{
services.AddScoped <IEpcisRequestStore, EpcisRequestStore>();
services.AddScoped <IEventFetcher, EventFetcher>();
services.AddScoped <IMasterdataFetcher, MasterdataFetcher>();
services.AddScoped <ISubscriptionManager, SubscriptionManager>();
services.AddScoped <IUserManager, UserManager>();
services.AddScoped(s => OpenConnection(connectionString));
DefaultTypeMap.MatchNamesWithUnderscores = true;
DatabaseMigrator.Migrate(connectionString);
return(services);
}
public void SetUp()
{
string folder = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DatabaseMigratorTests)).CodeBase);
MigrationsAssembly = Assembly.LoadFrom(new Uri(Path.Combine(folder, "SampleDbMigrations.dll")).LocalPath);
Settings = new Dictionary <string, string>
{
{ "Server", "." },
{ "Database", "TestDb" }
};
Log = new StringBuilder();
Logger = new StringLogger(Log);
DatabaseMigrator = new DatabaseMigrator(Logger, true, "SqlServer", -1, true);
}
public void GeneratedVersionedEntityDoesntNeedUpdate()
{
var databaseMigrator = new DatabaseMigrator();
var configuration = new VersionedConfiguration();
var answerProvider = new Mock <IAnswerProvider>();
databaseMigrator.Execute(configuration, connectionString, "System.Data.SqlClient", Enumerable.Empty <string>(), Enumerable.Empty <string>(), Enumerable.Empty <KeyValuePair <string, string> >(), answerProvider.Object);
var scriptGenerator = new ScriptGenerator();
var script = scriptGenerator.Generate(configuration, connectionString, "System.Data.SqlClient", Enumerable.Empty <string>(), Enumerable.Empty <string>(), Enumerable.Empty <KeyValuePair <string, string> >(), answerProvider.Object);
this.output.WriteLine(script);
Assert.True(string.IsNullOrWhiteSpace(script));
}
protected override void InitializeModules()
{
// NOTE: Method from the base class is not called to avoid NotSupportedException
var dbConnectionFactory = Container.Resolve <IDbConnectionFactory>();
DatabaseMigrator.Migrate(dbConnectionFactory);
var regionManager = Container.Resolve <IRegionManager>();
regionManager.RegisterViewWithRegion("ToolbarRegion", typeof(Views.ToolbarView));
regionManager.RegisterViewWithRegion("NavigationRegion", typeof(Notebook.Views.NavbarView));
regionManager.RegisterViewWithRegion("ContentRegion", typeof(Notebook.Views.TabContentView));
}
