public static void SetupMirroring(DatabaseInitializerParams param)
        {
            if (!string.IsNullOrEmpty(param.MirroringSharedFolder))
            {
                Console.WriteLine("Add Mirroring on the new Database ...");
                var creatorDb = new DatabaseCreator();

                Console.WriteLine("MirroringSharedFolder :" + param.MirroringSharedFolder);
                var backupFolder = Path.Combine(param.MirroringSharedFolder,
                                                param.CompanyName + DateTime.Now.ToString("dd-MM-yyyy_hh-mm-ss"));
                Directory.CreateDirectory(backupFolder);

                creatorDb.InitMirroring(param.MasterConnectionString, param.CompanyName);

                var mirrorDbExist = creatorDb.DatabaseExists(param.MirrorMasterConnectionString, param.CompanyName);
                if (mirrorDbExist)
                {
                    Console.WriteLine("Deleting existing mirroring db...");
                    creatorDb.DropDatabase(param.MirrorMasterConnectionString, param.CompanyName, false);
                }

                Console.WriteLine("Backup for mirroring...");
                creatorDb.BackupDatabase(param.MasterConnectionString, backupFolder, param.CompanyName);

                Console.WriteLine("Restoring mirroring backup...");
                creatorDb.RestoreDatabase(param.MirrorMasterConnectionString, backupFolder, param.CompanyName);

                Console.WriteLine("Set Mirroring Partner...");
                creatorDb.SetMirroringPartner(param.MirrorMasterConnectionString, param.CompanyName, param.MirroringMirrorPartner);
                Console.WriteLine("Complete Mirroring...");
                creatorDb.CompleteMirroring(param.MasterConnectionString, param.CompanyName, param.MirroringPrincipalPartner, param.MirroringWitness);
                Console.WriteLine("Mirroring Completed.");
            }
        }
        public static void UpdateSchema(DatabaseInitializerParams param)
        {
            Console.WriteLine("Update Schemas");

            StopAppPools(param);

            DbMigrationsConfiguration configuration = new apcurium.MK.Booking.Migrations.ConfigMigrationBookingContext();

            configuration.TargetDatabase = new DbConnectionInfo(param.MkWebConnectionString, "System.Data.SqlClient");

            var migrator = new DbMigrator(configuration);

            DisplayPendingMigrations(migrator);
            migrator.Update();


            configuration = new apcurium.MK.Common.Migrations.ConfigMigrationConfigurationContext
            {
                TargetDatabase = new DbConnectionInfo(param.MkWebConnectionString, "System.Data.SqlClient")
            };

            migrator = new DbMigrator(configuration);
            DisplayPendingMigrations(migrator);
            migrator.Update();
            Console.WriteLine("Update Schemas Done");
        }
        private static void StopAppPools(DatabaseInitializerParams param)
        {
            Console.WriteLine("Stop App Pool to finish Database Migration...");
            var iisManager = new ServerManager();
            var appPool    = iisManager.ApplicationPools.FirstOrDefault(x => x.Name == param.AppPoolName);

            if (appPool != null &&
                appPool.State == ObjectState.Started)
            {
                appPool.Stop();
                Console.WriteLine("App Pool stopped.");
            }

            if (param.SecondWebServerName.HasValue())
            {
                try
                {
                    Console.WriteLine("Stop Secondary App Pool ...");
                    using (var remoteServerManager = ServerManager.OpenRemote(param.SecondWebServerName))
                    {
                        var remoteAppPool = remoteServerManager.ApplicationPools.FirstOrDefault(x => x.Name == param.AppPoolName);

                        if (remoteAppPool != null && remoteAppPool.State == ObjectState.Started)
                        {
                            remoteAppPool.Stop();
                            Console.WriteLine("Remote App Pool stopped.");
                        }
                        else if (remoteAppPool == null)
                        {
                            Console.WriteLine("No AppPool named {0} found at {1}", param.SecondWebServerName, param.AppPoolName);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed to connect to remote server {0}", param.SecondWebServerName);
                    Console.WriteLine(ex.Message);
                }
            }
        }
        private void DeployDataBase(string packagesDirectory, string companyName, string appPoolName)
        {
            Log("Deploying DB");
            var jsonSettings = new JObject();

            foreach (var setting in _job.Company.CompanySettings)
            {
                if ((setting.Key != "IBS.WebServicesUrl") &&
                    (setting.Key != "IBS.WebServicesUserName") &&
                    (setting.Key != "IBS.WebServicesPassword") &&
                    (setting.Key != "IBS.RestApiUrl") &&
                    (setting.Key != "IBS.RestApiUser") &&
                    (setting.Key != "IBS.RestApiSecret"))
                {
                    jsonSettings.Add(setting.Key, JToken.FromObject(setting.Value ?? ""));
                }
            }

            jsonSettings.Add("IBS.RestApiUrl", JToken.FromObject(_job.Company.IBS.RestApiUrl ?? ""));
            jsonSettings.Add("IBS.RestApiUser", JToken.FromObject(_job.Company.IBS.RestApiUser ?? ""));
            jsonSettings.Add("IBS.RestApiSecret", JToken.FromObject(_job.Company.IBS.RestApiSecret ?? ""));

            jsonSettings.Add("IBS.WebServicesUrl", JToken.FromObject(_job.Company.IBS.ServiceUrl ?? ""));
            jsonSettings.Add("IBS.WebServicesUserName", JToken.FromObject(_job.Company.IBS.Username ?? ""));
            jsonSettings.Add("IBS.WebServicesPassword", JToken.FromObject(_job.Company.IBS.Password ?? ""));

            var fileSettings = Path.Combine(packagesDirectory, "DatabaseInitializer\\Settings\\") + companyName +
                               ".json";
            var stringBuilder = new StringBuilder();

            jsonSettings.WriteTo(new JsonTextWriter(new StringWriter(stringBuilder)));
            File.WriteAllText(fileSettings, stringBuilder.ToString());

            var p = new DatabaseInitializerParams
            {
                CompanyName                  = companyName,
                BackupFolder                 = ConfigurationManager.AppSettings["BackupFolder"],
                SqlInstanceName              = _job.Server.SqlServerInstance,
                MkWebConnectionString        = string.Format(ConfigurationManager.AppSettings["ToolSqlConnectionString"], companyName),
                MasterConnectionString       = ConfigurationManager.ConnectionStrings["SqlConnectionStringMaster"].ConnectionString,
                MirroringSharedFolder        = ConfigurationManager.AppSettings["MirroringSharedFolder"],
                MirroringMirrorPartner       = ConfigurationManager.AppSettings["MirroringMirrorPartner"],
                MirroringWitness             = ConfigurationManager.AppSettings["MirroringWitness"],
                MirroringPrincipalPartner    = ConfigurationManager.AppSettings["MirroringPrincipalPartner"],
                MirrorMasterConnectionString = ConfigurationManager.AppSettings["MirrorMasterConnectionString"],
                IsStaging           = ConfigurationManager.AppSettings["ServerName"].Equals("Staging"),
                AppPoolName         = appPoolName,
                SecondWebServerName = ConfigurationManager.AppSettings["SecondWebServerName"]
            };

            var paramFile = Guid.NewGuid().ToString().Replace("-", "") + ".params";

            File.WriteAllText(Path.Combine(packagesDirectory, "DatabaseInitializer\\") + paramFile, ServiceStack.Text.JsonSerializer.SerializeToString(p));

            var deployDb =
                ProcessEx.GetProcess(
                    Path.Combine(packagesDirectory, "DatabaseInitializer\\") + "DatabaseInitializer.exe",
                    "f:" + paramFile, Path.Combine(packagesDirectory, "DatabaseInitializer\\"), true);


            using (var exeProcess = Process.Start(deployDb))
            {
                exeProcess.OutputDataReceived += exeProcess_OutputDataReceived;
                var output = ProcessEx.GetOutput(exeProcess);
                if (exeProcess.ExitCode > 0)
                {
                    throw new Exception("Error during deploy DB step" + output);
                }

                Log("Deploying Database finished");
            }
        }
        private static DatabaseInitializerParams GetParamsFromArgs(string[] args)
        {
            var result = new DatabaseInitializerParams();

            Console.WriteLine("args : " + args.JoinBy(" "));
            if (args.Any() && !string.IsNullOrWhiteSpace(args[0]) && args[0].Trim().StartsWith("f:"))
            {
                var paramFile = Path.Combine(AssemblyDirectory, args[0].Trim().Substring(2, args[0].Trim().Length - 2));
                Console.WriteLine("Reading param file : " + paramFile);
                if (!File.Exists(paramFile))
                {
                    throw new ApplicationException("Parameteres file cannot be found");
                }
                var paramFileContent = File.ReadAllText(paramFile);

                result = JsonSerializer.DeserializeFromString <DatabaseInitializerParams>(paramFileContent);
            }
            result.CompanyName = string.IsNullOrWhiteSpace(result.CompanyName) ? LocalDevProjectName : result.CompanyName;

            //Sql instance name
            if (string.IsNullOrWhiteSpace(result.MkWebConnectionString) && (args.Length > 1))
            {
                result.SqlInstanceName = args[1];
            }
            else if (string.IsNullOrWhiteSpace(result.SqlInstanceName))
            {
                var sqlInstanceName = "MSSQL11.MSSQLSERVER";
                Console.WriteLine("Sql Instance name ? Default is MSSQL11.MSSQLSERVER , 1- MSSQL10_50.MSSQLSERVER, 2- MSSQL12.MSSQLSERVER, 3- MSSQL13.MSSQLSERVER");

                var userSqlInstance = Console.ReadLine();

                sqlInstanceName = string.IsNullOrEmpty(userSqlInstance)
                    ? sqlInstanceName
                    : userSqlInstance == "1"
                    ? "MSSQL10_50.MSSQLSERVER"
                    : userSqlInstance == "2"
                    ? "MSSQL12.MSSQLSERVER"
                    : userSqlInstance == "3"
                    ? "MSSQL13.MSSQLSERVER"
                    : sqlInstanceName;

                result.SqlInstanceName = sqlInstanceName;
                Console.WriteLine("Sql Directory Default is " + result.SqlServerDirectory);
            }

            //Company connection string
            if (string.IsNullOrWhiteSpace(result.MkWebConnectionString) && (args.Length > 3))
            {
                result.MkWebConnectionString = string.Format(args[3], result.CompanyName);
            }
            else if (string.IsNullOrWhiteSpace(result.MkWebConnectionString))
            {
                result.MkWebConnectionString = string.Format("Data Source=.;Initial Catalog={0};Integrated Security=True; MultipleActiveResultSets=True", result.CompanyName);
            }

            //Master connection string
            if (string.IsNullOrWhiteSpace(result.MasterConnectionString) && (args.Length > 4))
            {
                result.MasterConnectionString = string.Format(args[4], result.CompanyName);
            }
            else if (string.IsNullOrWhiteSpace(result.MasterConnectionString))
            {
                result.MasterConnectionString = result.MkWebConnectionString.Replace(result.CompanyName, "master");
            }

            if (string.IsNullOrWhiteSpace(result.AppPoolName))
            {
                result.AppPoolName = "DefaultAppPool";
            }

            Console.WriteLine("Running database initializer using the following settings : ");

            var j = result.ToJson();

            Console.WriteLine(j);

            return(result);
        }