コード例 #1
0
ファイル: UpgradeTool.cs プロジェクト: jalex/Swarm
        internal int GetExitCode(DatabaseUpgradeResult result)
        {
            if (!result.Successful)
            {
                logger.Error("An exception occurred while upgrading the database.", result.Error);

                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result.Error);
                Console.ResetColor();
                return(-1);
            }
            else
            {
                int count = result.Scripts.Count();

                stopwatch.Stop();
                TimeSpan elapsed  = stopwatch.Elapsed;
                string   duration = elapsed.ToString("mm':'ss");

                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("{0} scripts executed successfully. Done in {1}!", count, duration);
                Console.ResetColor();
                return(0);
            }
        }
コード例 #2
0
        public static int Main(string[] args)
        {
            string connectionString = Configuration["ConnectionStrings:PrimarySchoolDB"];

            EnsureDatabase.For.SqlDatabase(connectionString);

            UpgradeEngine upgrader =
                DeployChanges.To
                .SqlDatabase(connectionString)
                .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
                .LogToConsole()
                .Build();

            DatabaseUpgradeResult result = upgrader.PerformUpgrade();

            if (!result.Successful)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result.Error);
                Console.ResetColor();

                return(-1);
            }

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Success!");
            Console.ResetColor();
            return(0);
        }
コード例 #3
0
        public RunGroupOrderScenarios()
        {
            upgradeResult = null;
            scripts       = new List <SqlScript>
            {
                new SqlScript("ZZZScript1.sql", "create table Foo (Id int identity)", new SqlScriptOptions {
                    ScriptType = ScriptType.RunOnce, RunGroupOrder = DbUpDefaults.DefaultRunGroupOrder
                }),
                new SqlScript("ZZZScript2.sql", "alter table Foo add column Name varchar(255)", new SqlScriptOptions {
                    ScriptType = ScriptType.RunOnce, RunGroupOrder = DbUpDefaults.DefaultRunGroupOrder
                }),
                new SqlScript("AAAScript3.sql", "insert into Foo (Name) values ('test')", new SqlScriptOptions {
                    ScriptType = ScriptType.RunOnce, RunGroupOrder = DbUpDefaults.DefaultRunGroupOrder + 1
                })
            };

            logger = new CaptureLogsLogger();
            recordingConnection   = new RecordingDbConnection(logger, "SchemaVersions");
            testConnectionFactory = new DelegateConnectionFactory(_ => recordingConnection);

            upgradeEngineBuilder = DeployChanges.To
                                   .SqlDatabase("testconn")
                                   .WithScripts(new TestScriptProvider(scripts))
                                   .OverrideConnectionFactory(testConnectionFactory)
                                   .LogTo(logger);
        }
コード例 #4
0
        protected virtual DatabaseUpgradeResult ExecuteAlways(string connectionString, string scriptsPath, string configurationSpecificScriptsPath, IDictionary <string, string> variables)
        {
            DatabaseUpgradeResult result = new DatabaseUpgradeResult(new SqlScript[0], true, null);

            if (Directory.Exists(scriptsPath))
            {
                UpgradeEngineBuilder engineBuilder = DeployChanges.To
                                                     .SqlDatabase(connectionString)
                                                     .WithScriptsFromFileSystem(scriptsPath);

                if (configurationSpecificScriptsPath != null)
                {
                    engineBuilder = engineBuilder.WithScriptsFromFileSystem(configurationSpecificScriptsPath);
                }

                var engine = engineBuilder.JournalTo(new NullJournal())
                             .WithVariables(variables)
                             .LogToConsole()
                             .Build();

                result = engine.PerformUpgrade();
            }

            return(result);
        }
コード例 #5
0
        public Task <int> Undo()
        {
            Console.WriteLine($"Starting: {nameof(this.Undo)}");
            EnsureDatabase();

            DatabaseUpgradeResult result = null;

            result = _runner.Run(_callbacks.beforeUndo);

            // Collect
            var before   = _callbacks.beforeEachUndo;
            var after    = _callbacks.afterEachUndo;
            var afterErr = _callbacks.afterEachUndoError;

            result = _runner.Run(_provider.GetUndoScripts(), before, after, afterErr);

            if (!result.Successful)
            {
                _runner.Run(_callbacks.afterUndoError);
            }
            else
            {
                _runner.Run(_callbacks.afterUndo);
            }

            return(ParseReturn(result));
        }
コード例 #6
0
        public Task <int> Migrate()
        {
            Console.WriteLine($"Starting: {nameof(this.Migrate)}");
            EnsureDatabase();

            DatabaseUpgradeResult result = null;

            result = _runner.Run(_callbacks.beforeMigrate);
            if (!result.Successful)
            {
                return(ParseReturn(result));
            }

            // Collect
            var before   = _callbacks.beforeEachMigrate;
            var after    = _callbacks.afterEachMigrate;
            var afterErr = _callbacks.afterEachMigrateError;

            result = _runner.Run(_provider.GetVersionScripts(), before, after, afterErr);
            result = _runner.RunHashed(_provider.GetRepeatableScripts(), before, after, afterErr);

            if (!result.Successful)
            {
                _runner.Run(_callbacks.afterMigrateError);
            }
            else
            {
                _runner.Run(_callbacks.afterMigrate);
            }

            return(ParseReturn(result));
        }
コード例 #7
0
        public Task <int> Test()
        {
            Console.WriteLine($"Starting: {nameof(this.Test)}");
            EnsureDatabase();

            DatabaseUpgradeResult result = null;

            result = _runner.Run(_callbacks.beforeTest);

            // Collect
            var before   = _callbacks.beforeEachTest;
            var after    = _callbacks.afterEachTest;
            var afterErr = _callbacks.afterEachTestError;

            result = _runner.RunHashed(_provider.GetTestScripts(), before, after, afterErr);

            if (!result.Successful)
            {
                _runner.Run(_callbacks.afterTestError);
            }
            else
            {
                _runner.Run(_callbacks.afterTest);
                if (_testRunner != null)
                {
                    _testRunner.RunTests();
                }
            }

            return(ParseReturn(result));
        }
コード例 #8
0
        public UpgradeDatabaseScenarios()
        {
            upgradeResult = null;
            scripts       = new List <SqlScript>
            {
                new SqlScript("Script1.sql", "create table Foo (Id int identity)"),
                new SqlScript("Script2.sql", "alter table Foo add column Name varchar(255)"),
                new SqlScript("Script3.sql", "insert into Foo (Name) values ('test')")
            };

            executedScripts = new List <ExecutedSqlScript>
            {
                new ExecutedSqlScript {
                    Name = "Script1.sql", Hash = "a"
                },
                new ExecutedSqlScript {
                    Name = "Script2.sql", Hash = "b"
                },
                new ExecutedSqlScript {
                    Name = "Script3.sql", Hash = "c"
                }
            };

            logger = new CaptureLogsLogger();
            recordingConnection   = new RecordingDbConnection(logger, "SchemaVersions");
            testConnectionFactory = new DelegateConnectionFactory(_ => recordingConnection);

            upgradeEngineBuilder = DeployChanges.To
                                   .SqlDatabase("testconn")
                                   .WithScripts(new TestScriptProvider(scripts))
                                   .OverrideConnectionFactory(testConnectionFactory)
                                   .LogTo(logger);
        }
コード例 #9
0
ファイル: ResultReporter.cs プロジェクト: mhejle/geh-charges
 private static int ReportFailure(DatabaseUpgradeResult result)
 {
     Console.ForegroundColor = ConsoleColor.Red;
     Console.WriteLine(result.Error);
     Console.ResetColor();
     return(FailureResult);
 }
コード例 #10
0
        public DatabaseUpgradeResult UpgradeDatabase(string connectionString, string pathToChangelog, bool runRollbacks = true)
        {
            EnsureDatabase.For.SqlDatabase(connectionString);

            DatabaseUpgradeResult upgradeResult = PerformUpgrade(connectionString, Path.Combine(pathToChangelog, "schema\\1.0.X"),
                                                                 script => !script.Contains("_rollback"));

            if (!upgradeResult.Successful)
            {
                return(new DatabaseUpgradeResult(allExecutedScripts, upgradeResult.Successful, upgradeResult.Error));
            }

            //upgradeResult = PerformUpgrade(connectionString, Path.Combine(pathToChangelog, "procedures"),
            //    script => !script.Contains("_rollback"));
            //if (!upgradeResult.Successful)
            //    return new DatabaseUpgradeResult(allExecutedScripts, upgradeResult.Successful, upgradeResult.Error);

            if (runRollbacks)
            {
                //upgradeResult = PerformUpgrade(connectionString, Path.Combine(pathToChangelog, "procedures"),
                //    script => script.Contains("_rollback"));
                //if (!upgradeResult.Successful)
                //    return new DatabaseUpgradeResult(allExecutedScripts, upgradeResult.Successful, upgradeResult.Error);

                upgradeResult = PerformUpgrade(connectionString, Path.Combine(pathToChangelog, "schema\\1.0.X"),
                                               script => script.Contains("_rollback"));
                if (!upgradeResult.Successful)
                {
                    return(new DatabaseUpgradeResult(allExecutedScripts, upgradeResult.Successful, upgradeResult.Error));
                }
            }

            return(new DatabaseUpgradeResult(allExecutedScripts, upgradeResult.Successful, upgradeResult.Error));
        }
        public Task <int> Handle(UpgradeDatabaseCommand request, CancellationToken cancellationToken)
        {
            _logger.LogDebug("Running with Options={@DbUpOptions}", request);

            var connectionStringBuilder = new SqlConnectionStringBuilder(request.ConnectionString);

            var variables = new Dictionary <string, string>
            {
                { "environment", request.Environment },
                { "login_name", connectionStringBuilder.UserID },
                { "database_name", connectionStringBuilder.InitialCatalog },
            };

            UpgradeEngineBuilder builder = DeployChanges.To.SqlDatabase(request.ConnectionString)
                                           .WithScriptsFromFileSystem(request.ScriptsDirectory)
                                           .WithTransaction()
                                           .LogToLogger(_logger)
                                           .WithVariables(variables);

            if (!request.EnableJournaling)
            {
                builder = builder.JournalTo(new NullJournal());
            }

            DatabaseUpgradeResult result = builder
                                           .Build()
                                           .PerformUpgrade();

            return(Task.FromResult(result.Successful ? 0 : 1));
        }
コード例 #12
0
        internal static int Main(string[] args)
        {
            string connectionString      = args.FirstOrDefault();
            bool   dropDatabase          = Convert.ToBoolean(args[1]);
            DatabaseUpgradeResult result = RunDatabaseUpdate(connectionString, dropDatabase);

            return(!result.Successful ? ShowError(result.Error) : ShowSuccess());
        }
コード例 #13
0
 private void PrintResult(string resultType, DatabaseUpgradeResult executionResult)
 {
     Console.WriteLine($"Database {resultType} Result: {(executionResult.Successful ? "Success" : "Error")}");
     if (!executionResult.Successful)
     {
         Console.WriteLine(executionResult.Error);
     }
 }
コード例 #14
0
        private static void WriteResultErrorToConsole(DatabaseUpgradeResult result)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(result.Error);
            Console.ResetColor();
#if DEBUG
            Console.ReadLine();
#endif
        }
コード例 #15
0
 public static void WriteExecutedScriptsToOctopusTaskSummary(this DatabaseUpgradeResult result)
 {
     Console.WriteLine("##octopus[stdout-highlight]");
     Console.WriteLine($"Ran {result.Scripts.Count()} script{(result.Scripts.Count() == 1 ? "" : "s")}");
     foreach (var script in result.Scripts)
     {
         Console.WriteLine(script.Name);
     }
     Console.WriteLine("##octopus[stdout-default]");
 }
コード例 #16
0
        protected virtual DatabaseUpgradeResult ExecuteAlways(AlwaysScriptType alwaysScriptType, string migrationsDirectory, string connectionString, string configuration, string configurationDefault, IDictionary <string, string> variables)
        {
            EnsureDatabase.For.SqlDatabase(connectionString);

            string scriptsPath = Path.Combine(migrationsDirectory, alwaysScriptType.ToString());
            string configurationSpecificScriptsPath = GetConfigurationSpecificScriptsPath(scriptsPath, configuration, configurationDefault);
            DatabaseUpgradeResult result            = ExecuteAlways(connectionString, scriptsPath, configurationSpecificScriptsPath, variables);

            return(result);
        }
コード例 #17
0
        private bool HandleResult(DatabaseUpgradeResult result)
        {
            if (!result.Successful)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result.Error);
                Console.ResetColor();
            }

            return(result.Successful);
        }
コード例 #18
0
ファイル: Program.cs プロジェクト: S-Sudarsan/DBUP-Poc
        private static bool IsError(DatabaseUpgradeResult result)
        {
            if (!result.Successful)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result.Error);
                Console.ResetColor();
                Console.ReadLine();
                return(true);
            }

            return(false);
        }
コード例 #19
0
ファイル: DbMigrator.cs プロジェクト: pbadilla-pl/azakaw-demo
        private bool RunNonIdempotentMigrationScripts()
        {
            builder = DeployChanges.To.PostgresqlDatabase(connectionString);
            var upgrader = builder
                           .WithScriptsEmbeddedInAssembly(
                Assembly.GetExecutingAssembly(),
                fileName => !fileName.ContainsKeyword(IdempotentScriptIndicator))
                           .Build();

            DatabaseUpgradeResult upgradeResult = upgrader.PerformUpgrade();

            return(upgradeResult.Successful);
        }
コード例 #20
0
        internal void ReportResult_WhenFailure_ReturnFailureResponse(
            Mock <IEnumerable <SqlScript> > scripts,
            Mock <SqlScript> script,
            Mock <Exception> exception)
        {
            // Arrange
            var upgradeResult = new DatabaseUpgradeResult(scripts.Object, false, exception.Object, script.Object);

            // Act
            var result = ResultReporter.ReportResult(upgradeResult);

            // Assert
            Assert.Equal(FailureResult, result);
        }
コード例 #21
0
 private static void DisplayResult(DatabaseUpgradeResult result)
 {
     if (result.Successful)
     {
         Console.ForegroundColor = ConsoleColor.Green;
         Console.WriteLine("Success.");
     }
     else
     {
         Console.ForegroundColor = ConsoleColor.Red;
         Console.WriteLine(result.Error);
     }
     Console.ResetColor();
 }
コード例 #22
0
ファイル: Deployer.cs プロジェクト: ishootrayguns/AirBnb
        public static DatabaseUpgradeResult DeployTestSeedData(string connectionString)
        {
            EnsureDatabase.For.SqlDatabase(connectionString);
            UpgradeEngine upgrader = DeployChanges.To
                                     .SqlDatabase(connectionString)
                                     .WithTransactionPerScript()
                                     .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly(), (s) => { return(s.Contains("SeedData")); })
                                     .LogToConsole()
                                     .Build();

            DatabaseUpgradeResult result = upgrader.PerformUpgrade();

            return(result);
        }
コード例 #23
0
 private Task <int> ParseReturn(DatabaseUpgradeResult result,
                                [System.Runtime.CompilerServices.CallerMemberName] string caller = null)
 {
     if (result.Successful)
     {
         Console.WriteLine($"Finished Successful: {caller}");
         return(Task.FromResult(0));
     }
     else
     {
         Console.WriteLine($"Finished Failed: {caller}");
         return(Task.FromResult(1));
     }
 }
コード例 #24
0
        private static void HandleMigrationResults(DatabaseUpgradeResult result, bool reset = false)
        {
            if (!result.Successful && (!reset || result.Error.Message != "Invalid object name 'SchemaVersions'."))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result.Error);
                Console.ResetColor();
                Environment.Exit(-1);
            }

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Success!");
            Console.ResetColor();
        }
コード例 #25
0
        private static string WriteExecutedScriptsToOctopusTaskSummary(DatabaseUpgradeResult result)
        {
            var sb = new StringBuilder();

            sb.AppendLine("##octopus[stdout-highlight]");
            sb.AppendLine($"Ran {result.Scripts.Count()} script{(result.Scripts.Count() == 1 ? "" : "s")}");
            foreach (var script in result.Scripts)
            {
                sb.AppendLine(script.Name);
                sb.AppendLine(script.Contents);
            }

            sb.AppendLine("##octopus[stdout-default]");
            return(sb.ToString());
        }
コード例 #26
0
        public static void UseMigration(this IApplicationBuilder app, string connectionString)
        {
            DropDatabase.For.SqlDatabase(connectionString);
            EnsureDatabase.For.SqlDatabase(connectionString);

            UpgradeEngine upgrader = DeployChanges.To
                                     .SqlDatabase(connectionString)
                                     .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
                                     .LogToConsole()
                                     .Build();

            DatabaseUpgradeResult result = upgrader.PerformUpgrade();

            ShowMessage(result);
        }
コード例 #27
0
        private static int InstallTests(string connectionString)
        {
            UpgradeEngine upgradeEngine = DeployChanges
                                          .To
                                          .SqlDatabase(connectionString)
                                          .WithScriptsFromFileSystem(TESTS_PATH, new FileSystemScriptOptions {
                IncludeSubDirectories = true
            })
                                          .JournalTo(new NullJournal())
                                          .Build();

            DatabaseUpgradeResult databaseUpgradeResult = upgradeEngine.PerformUpgrade();

            return(!databaseUpgradeResult.Successful ? ShowError(databaseUpgradeResult.Error) : ShowSuccess());
        }
コード例 #28
0
ファイル: Global.asax.cs プロジェクト: valdanuni/PS
        private static void SetupDatabase()
        {
            EnsureDatabase.For.SqlDatabase(DataContext.GetDatabaseConnectionString());
            UpgradeEngine dbUpgradeEngine = DeployChanges.To.SqlDatabase(DataContext.GetDatabaseConnectionString())
                                            .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
                                            .LogToConsole()
                                            .Build();

            DatabaseUpgradeResult dbUpgradeResult = dbUpgradeEngine.PerformUpgrade();

            if (!dbUpgradeResult.Successful)
            {
                throw new ApplicationException("Database setup failed", dbUpgradeResult.Error);
            }
        }
コード例 #29
0
        static int Main(string[] args)
        {
            var connectionName = "dissertation";

            var connectionString = Environment.GetEnvironmentVariable($"SQLAZURECONNSTR_{connectionName}");

            if (string.IsNullOrEmpty(connectionString))
            {
                connectionString = args.FirstOrDefault()
                                   ?? ConfigurationManager.ConnectionStrings[connectionName].ConnectionString;
            }

            Console.WriteLine($"Connection string: {connectionString}");

            DatabaseUpgradeResult result = null;

            try
            {
                var upgrader =
                    DeployChanges.To
                    .SqlDatabase(connectionString)
                    .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
                    .LogToConsole()
                    .Build();

                result = upgrader.PerformUpgrade();
            }
            catch (Exception)
            {
                Console.WriteLine($"Connection string: {connectionString}");
            }

            if (result == null || !result.Successful)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(result == null ? "result is null" : $"{result.Error}");
                Console.ResetColor();
#if DEBUG
                Console.ReadLine();
#endif
                return(-1);
            }

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Success!");
            Console.ResetColor();
            return(0);
        }
コード例 #30
0
        private DatabaseUpgradeResult PerformUpgrade(string connectionString, string filesInPath, Func <string, bool> fileNameFilter)
        {
            UpgradeEngineBuilder builder = DeployChanges
                                           .To
                                           .SqlDatabase(connectionString)
                                           .WithTransaction()
                                           //.WithTransactionAlwaysRollback()
                                           .WithVariablesDisabled()
                                           .WithScriptsFromFileSystem(filesInPath, fileNameFilter);

            DatabaseUpgradeResult result = builder.Build().PerformUpgrade();

            allExecutedScripts.AddRange(result.Scripts);

            return(result);
        }
コード例 #31
0
 public UpgradeModel(DatabaseUpgradeResult[] results, string log)
 {
     Results = results;
     Log = log;
 }